class NotmuchMailChecker(Backend):
    """
    This class uses the notmuch python bindings to check for the
    number of messages in the notmuch database with the tags "inbox"
    and "unread"
    """

    settings = required = ("db_path",)

    def init(self):
        self.db = notmuch.Database(self.db_path)

    @property
    def unread(self):
        return notmuch.Query(self.db, "tag:unread and tag:inbox").count_messages()

status = i3pystatus(standalone=True)

status.register(clock,
    format="%a %-d %b %X"
)

status.register(mail.Mail(
    backends=[thunderbird.Thunderbird()],
    format="@{unread}",
    format_plural="@{unread}",
))

status.register(modsde,
    username="csde_rats",
    password="1234",
    format="M{unread}",
    offset=636,
)

status.register(regex, 
    regex="speed:\s+([0-9]+)\nlevel:\s+([a-zA-Z0-9]+)",
    file="/proc/acpi/ibm/fan",
    format="{0}/{1}",
)

status.register(battery)

status.run()

    def register(self, module, position=0, *args, **kwargs):
        """Register a new module."""

        module, position = self.get_instance_for_module(module, position, args, kwargs)

        self.modules.append(module)
        module.position = position
        module.registered(self)

    def get_instance_for_module(self, module, position, args, kwargs):
        if isinstance(module, types.ModuleType):
            if not isinstance(position, int) and not args:
                args = (position,)
                position = 0

            module = self.finder.instanciate_class_from_module(module, *args, **kwargs)

        return (module, position)

ModuleFinder = functools.partial(ClassFinder, baseclass=Module, exclude=[Module, IntervalModule, AsyncModule])

class ClassFinder:
    """Support class to find classes of specific bases in a module"""

    def __init__(self, baseclass, exclude=[]):
        self.baseclass = baseclass
        self.exclude = exclude

    def predicate(self, obj):
        return inspect.isclass(obj) and issubclass(obj, self.baseclass) and obj not in self.exclude

    def search_module(self, module):
        # Neat trick: [(x,y),(u,v)] becomes [(x,u),(y,v)]
        return list(zip(*inspect.getmembers(module, self.predicate)))[1]

    def get_class(self, module):
        classes = self.search_module(module)

        if len(classes) > 1:
            # If there are multiple Module clases bundled in one module,
            # well, we can't decide for the user.
            raise ConfigAmbigiousClassesError(module.__name__, classes)
        elif not classes:
            raise ConfigInvalidModuleError(module.__name__)

        return classes[0]

    def instanciate_class_from_module(self, module, *args, **kwargs):
        return self.get_class(module)(*args, **kwargs)

class SettingsBase:
    def __init__(self, *args, **kwargs):
        def flatten_settings(settings):
            return tuple((flatten_setting(setting) for setting in settings))

        def flatten_setting(setting):
            return setting[0] if isinstance(setting, tuple) else setting

        self.settings = flatten_settings(self.settings)

        required = set()
        self.required = set(self.required)

        if len(args) == 1 and not kwargs:
            # User can also pass in a dict for their settings
            # Note: you could do that anyway, with the ** syntax
            kwargs = args[0]

        for key, value in kwargs.items():
            if key in self.settings:
                setattr(self, key, value)
                required.add(key)
            else:
                raise ConfigKeyError(type(self).__name__, key=key)

        # Some nice set magic :-) [that's more efficient if we have classes with a few thousand settings]
        required &= set(self.required)
        if len(required) != len(self.required):
            raise ConfigMissingError(type(self).__name__, self.required-required)

        self.__name__ = "{}.{}".format(self.__module__, self.__class__.__name__)

        self.init()