def load_providers_config():
  providers = {}
  for pkg in werk_utils.find_modules('%s.providers' % __package__, True):
    cfg = werk_utils.import_string('%s.CONFIG' % pkg, True)
    if cfg and cfg.get('name'):
        providers[cfg['name']] = cfg
  return providers

def register_manager(manager):
    """Register all manager plugins and default commands with the manager."""
    from six.moves.urllib.parse import urlparse
    from flask.ext.script.commands import Shell, Server, ShowUrls, Clean
    managers = RegistryProxy('managers', ModuleAutoDiscoveryRegistry, 'manage')

    with manager.app.app_context():
        for script in find_modules('invenio.base.scripts'):
            manager.add_command(script.split('.')[-1],
                                import_string(script + ':manager'))
        for script in managers:
            if script.__name__ == 'invenio.base.manage':
                continue
            manager.add_command(script.__name__.split('.')[-2],
                                getattr(script, 'manager'))

    manager.add_command("clean", Clean())
    manager.add_command("show-urls", ShowUrls())
    manager.add_command("shell", Shell())
    parsed_url = urlparse(manager.app.config.get('CFG_SITE_URL'))
    port = parsed_url.port or 80
    host = parsed_url.hostname or '127.0.0.1'
    manager.add_command("runserver", Server(host=host, port=port))

    from invenio.ext.collect import collect
    collect.init_script(manager)

    # Added for B2SHARE for debugging purposes
    print("Available blueprints:", [x.name for x in manager.app.blueprints.values()])

def register_manager(manager):
    """Register all manager plugins and default commands with the manager."""
    from six.moves.urllib.parse import urlparse
    managers = RegistryProxy('managers', ModuleAutoDiscoveryRegistry, 'manage')

    with manager.app.app_context():
        for script in find_modules('invenio.base.scripts'):
            manager.add_command(script.split('.')[-1],
                                import_string(script + ':manager'))
        for script in managers:
            if script.__name__ == 'invenio.base.manage':
                continue
            manager.add_command(script.__name__.split('.')[-2],
                                getattr(script, 'manager'))

    manager.add_command("clean", Clean())
    manager.add_command("show-urls", ShowUrls())
    manager.add_command("shell", Shell())
    parsed_url = urlparse(manager.app.config.get('CFG_SITE_URL'))
    port = parsed_url.port or 80
    host = parsed_url.hostname or '127.0.0.1'
    runserver = Server(host=host, port=port)
    manager.add_command("runserver", runserver)

    # FIXME separation of concerns is violated here.
    from invenio.ext.collect import collect
    collect.init_script(manager)

    from invenio.ext.assets import command, bower
    manager.add_command("assets", command)
    manager.add_command("bower", bower)

    def _discover_module(self, pkg):
        import_str = pkg + '.' + self.module_name

        blacklist = self.app.config.get(
            '%s_%s_EXCLUDE' % (self.cfg_var_prefix, self.module_name.upper()),
            []
        )

        try:
            import_string(import_str, silent=self.silent)
        except ImportError as e:  # pylint: disable=C0103
            self._handle_importerror(e, pkg, import_str)
            return
        except SyntaxError as e:
            self._handle_syntaxerror(e, pkg, import_str)
            return

        for m in find_modules(import_str):
            if m in blacklist:  # Exclude specific package
                continue
            try:
                module = import_string(m, silent=self.silent)
                if module is not None:
                    self.register(module)
            except ImportError as e:  # pylint: disable=C0103
                self._handle_importerror(e, import_str, m)
            except SyntaxError as e:
                self._handle_syntaxerror(e, import_str, m)

def iter_suites(packages=None):
    """Yield all testsuites."""
    from werkzeug.utils import import_string, find_modules
    from flask_registry import ModuleAutoDiscoveryRegistry, \
        ImportPathRegistry

    app = create_app()

    if packages is None:
        testsuite = ModuleAutoDiscoveryRegistry('testsuite', app=app)
        from invenio import testsuite as testsuite_invenio
        testsuite.register(testsuite_invenio)
    else:
        exclude = map(lambda x: x + '.testsuite',
                      app.config.get('PACKAGES_EXCLUDE', []))
        testsuite = ImportPathRegistry(initial=packages, exclude=exclude,
                                       load_modules=True)

    for package in testsuite:
        for name in find_modules(package.__name__):
            module = import_string(name)
            if not module.__name__.split('.')[-1].startswith('test_'):
                continue
            if hasattr(module, 'TEST_SUITE'):
                yield module.TEST_SUITE
            else:
                app.logger.warning(
                    "%s: No test suite defined." % module.__name__)

def register_blueprints(app):
    for name in find_modules('blog.views'):
        mod = import_string(name)
        if hasattr(mod, 'bp'):
            app.register_blueprint(mod.bp)
    app.add_url_rule('/graphql', view_func=GraphQLView.as_view(
        'graphql', schema=schema, graphiql=True))

    def load_controllers(self):
        """Load all controllers from the application, so the routing cache gets
        filled."""
        for mod in find_modules(self.appname+".controllers"):
            self.controllers[mod.split('.')[-1]] = __import__(mod, None, None, ['']).controller

        self.loaded_controllers = True

    def autodiscover(self, paths, models=None, module_names=None):
        """
        Automatically register all Kibble views under ``path``.

        :param paths: The module paths to search under.
        :param module_names: A list of module names to match on. e.g. `kibble`
            will only attempt to autodiscover `kibble.py` files.
        :param models: A list of model kinds (either a ``ndb.Model`` subclass
            or a string) (Optional)
        """
        from werkzeug.utils import find_modules, import_string
        from .base import KibbleMeta

        all_models = models is None
        models = [
            (x._kind() if isinstance(x, ndb.Model) else x)
            for x in models or []]

        for p in paths:
            for mod in find_modules(p, True, True):
                # logger.debug("Autodiscover: %s", mod)
                if module_names is None \
                        or mod.rsplit('.', 1)[-1] in module_names:
                    import_string(mod)

        for view in KibbleMeta._autodiscover:
            if view.model and (all_models or view.kind() in models):
                self.register_view(view)

def iter_suites(name=None):
    name = name or __name__

    for module in find_modules(name):
        mod = import_string(module)
        if hasattr(mod, 'suite'):
            yield mod.suite()

def import_module_from_packages(name, app=None, packages=None, silent=False):
    if packages is None:
        if app is None and has_app_context():
            app = current_app
        if app is None:
            raise Exception(
                'Working outside application context or provide app'
            )
        #FIXME
        packages = app.config.get('PACKAGES', [])

    for package in packages:
        if package.endswith('.*'):
            for module in find_modules(package[:-2], include_packages=True):
                try:
                    yield import_string(module + '.' + name, silent)
                except ImportError:
                    pass
                except Exception as e:
                    import traceback
                    traceback.print_exc()
                    app.logger.error('Could not import: "%s.%s: %s',
                                     module, name, str(e))
                    pass
            continue
        try:
            yield import_string(package + '.' + name, silent)
        except ImportError:
            pass
        except Exception as e:
            import traceback
            traceback.print_exc()
            app.logger.error('Could not import: "%s.%s: %s',
                             package, name, str(e))
            pass

def import_module_from_packages(name, app=None, packages=None, silent=False):
    """Import modules from packages."""
    warnings.warn("Use of import_module_from_packages has been deprecated."
                  " Please use Flask-Registry instead.",  DeprecationWarning)

    if app is None and has_app_context():
        app = current_app
    if app is None:
        raise Exception(
            'Working outside application context or provide app'
        )

    if packages is None:
        packages = app.config.get('PACKAGES', [])

    for package in packages:
        if package.endswith('.*'):
            for module in find_modules(package[:-2], include_packages=True):
                try:
                    yield import_string(module + '.' + name, silent)
                except ImportError:
                    pass
                except Exception:
                    app.logger.exception("could not import %s.%s",
                                         package, name)
            continue
        try:
            yield import_string(package + '.' + name, silent)
        except ImportError:
            pass
        except Exception:
            app.logger.exception("could not import %s.%s", package, name)

def register_all_blueprints(app, blueprint_module):
    if blueprint_module:
        for name in find_modules(blueprint_module, include_packages=True, recursive=True):
            mod = import_string(name)
            for item_name in dir(mod):
                item = getattr(mod, item_name)
                if isinstance(item, Blueprint):
                    app.register_blueprint(item)

def register_api(api):
  for pkg in w_utils.find_modules('apps', True):
    pkg_api = '%s.api' % pkg
    resources = get_module_obj(pkg_api, 'API')
    if not resources:
      continue
    for resource in resources:
      register_api_resource(api, resource)

def register_apps(app):
  for pkg in w_utils.find_modules('apps', True):
    pkg_views = '%s.views' % pkg
    objs = [get_module_obj(pkg_views, obj) for obj in ['bpa', 'bp']]
    funcy.walk(funcy.silent(app.register_blueprint), objs)
    app_init = get_module_obj(pkg, 'app_init')
    if app_init:
      app_init(app)

    def is_module_exist(self):
        """Checks if module exists by the module name as the parameter:

               is_module_exist('app.views')

        Throws the error string to the console output if no module found
        but doesn't raise any exception. Returns bool value.
        """
        error_map = {'settings': NO_SETTINGS_ERROR}
        try:
            find_modules(self.module_name)
            return True
        except ImportError:
            if self.module_name in error_map.keys():
                sys.stderr.write(error_map[self.module_name])
            else:
                sys.stderr.write(NO_MODULE_COMMON_ERROR.format(self.module_name))
            return False

def register_blueprints(app):
    """Register all blueprint modules
    Reference: Armin Ronacher, "Flask for Fun and for Profit" PyBay 2016.
    """
    for name in find_modules('flaskr.blueprints'):
        mod = import_string(name)
        if hasattr(mod, 'bp'):
            app.register_blueprint(mod.bp)
    return None

    def load_generators(cls, pkg):

        cls.registry = dict()

        from importlib import import_module
        from werkzeug.utils import find_modules

        for module_name in find_modules(pkg, False, True):
            module = import_module(module_name)

    def load_drivers(cls):
        # Initialize the registry only if it has not yet been initialized
        if DriverRegistry.registry is None:
            DriverRegistry.registry = dict()

        from importlib import import_module
        from werkzeug.utils import find_modules

        for module_name in find_modules(__package__, True):
            module = import_module(module_name)

 def load_models(self):
     """Recursivly import all models from our application, so SQLAlchemy can
     track them and we can create_all() them. (;"""
     
     try:
         for mod in find_modules(self.appname+".models"):
             __import__(mod, None, None, [''])
     except ValueError:
         # Models is not a package, so we treat it as module
         self.application.import_from_app("models")

def iter_builtin_plugins():
    """Iterates over all built-in plugins that exist in Lektor."""
    for module in find_modules('lektor.plugins', include_packages=True):
        mod = import_string(module)
        for key, value in mod.__dict__.iteritems():
            try:
                if key[:1] != '_' and value is not Plugin and \
                   issubclass(value, Plugin):
                    yield 'core-' + module.split('.')[-1], value
            except TypeError:
                pass