def main(entrypoint, adapter, host, port, debug, level):
    if '.' not in sys.path:
        sys.path.insert(0, '.')

    # Get the API object
    api = import_string(entrypoint)
    if not isinstance(api, RESTArt):
        raise RuntimeError(
            'The object specified by entrypoint %r is not an '
            'instance of `restart.api.RESTArt`' % str(entrypoint)
        )

    # Get the adapter class
    adapter_class = import_string(adapter)
    if not issubclass(adapter_class, Adapter):
        raise RuntimeError(
            'The class specified by adapter %r is not a subclass '
            'of `restart.adapter.Adapter`' % str(adapter)
        )

    # Change the level of the global logger
    from .logging import global_logger
    global_logger.setLevel(level)

    # Run the API as a service
    service = Service(api, adapter_class)
    service.run(host, port, debug)

    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 try_to_eval(string, context={}, **general_context):
    """Take care of evaluating the python expression.

    If an exception happens, it tries to import the needed module.

    @param string: String to evaluate
    @param context: Context needed, in some cases, to evaluate the string

    @return: The value of the expression inside string
    """
    if not string:
        return None

    res = None
    imports = []
    general_context.update(context)
    simple = False
    while True:
        try:
            # kwalitee: disable=eval
            res = eval(string, globals().update(general_context), locals())
        except NameError as err:
            #Try first to import using werkzeug import_string
            try:
                from werkzeug.utils import import_string
                if "." in string:
                    part = string.split('.')[0]
                    import_string(part)
                    for i in string.split('.')[1:]:
                        part += '.' + i
                        import_string(part)
                    continue
                else:
                    simple = True
            except:
                pass

            import_name = str(err).split("'")[1]
            if import_name not in imports:
                if import_name in context:
                    globals()[import_name] = context[import_name]
                else:
                    globals()[import_name] = __import__(import_name)
                    imports.append(import_name)
                continue
            elif simple:
                import_name = str(err).split("'")[0]
                if import_name in context:
                    globals()[import_name] = context[import_name]
                else:
                    globals()[import_name] = __import__(import_name)
                    imports.append(import_name)
                continue

            raise ImportError("Can't import the needed module to evaluate %s"
                              (string, ))
        import os
        if isinstance(res, type(os)):
            raise ImportError
        return res

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 create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])

    db.init_app(app)
    csrf.init_app(app)
    bcrypt.init_app(app)
    mail.init_app(app)
    login_manager.init_app(app)
    redis_store.init_app(app)
    celery.conf.update(app.config)

    models_committed.connect(receive_change, app)

    sign_in_manage = {}
    sign_in_func = 'account.sign_in'
    for path in blueprints:
        bp = import_string('sayit.views.' + path[0])
        app.register_blueprint(bp, url_prefix=path[1])
        sign_in_manage[bp.name] = sign_in_func

    for path in jinja_filters:
        flt = import_string('sayit.filters:' + path[0])
        app.jinja_env.filters[path[1]] = flt

    login_manager.blueprint_login_views = sign_in_manage

    return app

def serializer(metadata_prefix):
    """Return etree_dumper instances."""
    metadataFormats = current_app.config['OAISERVER_METADATA_FORMATS']
    serializer_ = metadataFormats[metadata_prefix]['serializer']
    if isinstance(serializer_, tuple):
        return partial(import_string(serializer_[0]), **serializer_[1])
    return import_string(serializer_)

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 _get_search_results(self, q):
        from flask_cms.app import app

        results = {}
        searchable_models = app.config.get("SEARCHABLE_MODELS", [])
        for model in searchable_models:
            model_string = model[0]
            model_class = import_string(model_string)

            # Only get these columns from db
            columns_to_select = model[2]
            entities = [import_string("{}.{}".format(model_string, column))
                        for column in columns_to_select]

            # build search condition
            searchable_columns = model[1]
            column_objs = [import_string("{}.{}".format(model_string, column))
                           for column in searchable_columns]
            search_condition = [obj.like("%{}%".format(q))
                                for obj in column_objs]

            # query model with entities for search condition
            model_results = (model_class.query.
                             with_entities(*entities).
                             filter(or_(*search_condition)).
                             params(q=q).all())
            if model_results:
                results[model_class.__tablename__] = model_results
        return results

    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 test_import_string_attribute_error():
    with pytest.raises(AttributeError) as foo_exc:
        utils.import_string('tests.res.foo')
    assert 'screw your import' in str(foo_exc)

    with pytest.raises(AttributeError) as bar_exc:
        utils.import_string('tests.res.bar')
    assert 'screw your import' in str(bar_exc)

 def __init__(self):
   # avoid 'no implementation for kind' error.
   import_string(settings.AUTH_USER_MODEL)
   if not 'kay.sessions.middleware.SessionMiddleware' in \
         settings.MIDDLEWARE_CLASSES:
     raise ImproperlyConfigured(
       "The DatastoreBackend requires session middleware to "
       "be installed. Edit your MIDDLEWARE_CLASSES setting to insert "
       "'kay.sessions.middleware.SessionMiddleware'.")

def run(*args):
    # XXX: Need to import here before manager is run to ensure additional
    # commands are registered
    for mod in 'account', 'video':
        import_string('wonder.romeo.%s.commands' % mod)

    if args:
        return manager.handle(sys.argv[0], args)
    else:
        return manager.run()

def test_import_string_attribute_error(tmpdir, monkeypatch):
    monkeypatch.syspath_prepend(str(tmpdir))
    tmpdir.join('foo_test.py').write('from bar_test import value')
    tmpdir.join('bar_test.py').write('raise AttributeError("screw you!")')
    with pytest.raises(AttributeError) as foo_exc:
        utils.import_string('foo_test')
    assert 'screw you!' in str(foo_exc)

    with pytest.raises(AttributeError) as bar_exc:
        utils.import_string('bar_test')
    assert 'screw you!' in str(bar_exc)

    def init_app(self, app, elasticsearch=None):
        """Flask application initialization."""
        self.init_config(app)
        # Configure elasticsearch client.
        self._clients[app] = elasticsearch

        for autoindex in app.config.get('SEARCH_AUTOINDEX', []):
            import_string(autoindex)

        app.cli.add_command(index_cmd)
        app.extensions['invenio-search'] = self

def init_tasks(app):
    """
    Extracts modules (task types) from global configuration

    :param app: Current Flask application instance
    :type app: Flask.Flask

    :return: Dictionary with instantiated *TaskType objects
    :rtype: dict
    """
    task_types = {}
    loaders = {}
    enabled_tasks = app.config.get("ENABLED_TASKS", {})

    for plugin, task in enabled_tasks.iteritems():
        task_settings = import_string(
            "{plugin_name}.settings".format(plugin_name=plugin)
        )
        plugin_instance = import_string(
            "{plugin_name}".format(plugin_name=plugin))
        settings = plugin_instance.configure(task_settings)

        task_instance = import_string(
            "{plugin_name}.models.task_types.{task}".format(
                plugin_name=plugin, task=task)
        )
        static_path = import_string(plugin).__path__[0]

        js_name = 'plugin_js_{task}'.format(task=task_instance.type_name)
        css_name = 'plugin_css_{task}'.format(task=task_instance.type_name)

        if len(task_instance.JS_ASSETS) > 0:
            js = Bundle(*map(lambda x: os.path.join(static_path, x),
                             task_instance.JS_ASSETS),
                        output="scripts/{name}.js".format(name=js_name),
                        filters=app.config.get('JS_ASSETS_FILTERS', ''))
            app.assets.register(js_name, js)

        if len(task_instance.CSS_ASSETS) > 0:
            css = Bundle(*map(lambda x: os.path.join(static_path, x),
                              task_instance.CSS_ASSETS),
                         output="styles/{name}.css".format(name=css_name),
                         filters=app.config.get('CSS_ASSETS_FILTERS', ''))

            app.assets.register(css_name, css)

        loaders[task_instance.type_name] = jinja2.PackageLoader(plugin)
        task_types[task_instance.type_name] = task_instance(settings=settings)

    app.jinja_loader = jinja2.ChoiceLoader([
        app.jinja_loader,
        jinja2.PrefixLoader(loaders)])

    return task_types

 def record_file_factory(self):
     """Load default storage factory."""
     imp = self.app.config.get("FILES_REST_RECORD_FILE_FACTORY")
     if imp:
         import_string(imp)
     else:
         try:
             get_distribution('invenio-records-files')
             from invenio_records_files.utils import record_file_factory
             return record_file_factory
         except DistributionNotFound:
             return lambda pid, record, filename: None

    def add_blueprint(self, name, kw):
        join_name = lambda n, s: '%s.%s' % (n, s)

        for module in self.config['LOAD_MODULES_EXTENSIONS']:
            try:
                import_string(join_name(name, module))
            except (ImportError, AttributeError):
                # print 'No {e_module} found in {e_name}.'.format(e_module=module, e_name=name)
                pass

        blueprint = import_string(join_name(name, 'app'))
        self.register_blueprint(blueprint, **kw)

def register_blueprint(app, app_package, module_name="app", blueprint_name="module", on_error=None):
    """Automatically load Blueprint from the specified package and registers them with Flask."""

    #TODO: simplify for our case

    if not app_package:
        raise ValueError("No apps package provided - unable to begin autoload")

    if isinstance(app_package, basestring):
        package_code = import_string(app_package)
    else:
        #: `apps_package` can be the already imported parent package
        #: (i.e. the following is a licit pattern)::
        #:
        #:      import app_package
        #:      # do something else with app_package
        #:      autoload(app, app_package)
        package_code = app_package
        app_package = app_package.__name__

    package_paths = package_code.__path__

    package_paths = [path.join(path.dirname(app.root_path), p) for p in package_paths]
    root = app_package
    app_package = app_package + u"." if not app_package.endswith(".") else app_package

    if on_error is None:
        on_error = lambda name: app.logger.warn("Unable to import {name}.".format(name=name))

    _to_import = "{base}.{module}.{symbol}"
    import_template = lambda base: _to_import.format(base=base,
                                                     module=module_name,
                                                     symbol=blueprint_name)

    #: Autoloaded apps must be Python packages
    #: The root of the package is ONLY inspected for a routing file
    package_contents = [[None, root, True]]
    for _, sub_app_name, is_pkg in package_contents:

        if not is_pkg:
            continue

        sub_app_import_path = import_template(base=sub_app_name)
        sub_app = import_string(sub_app_import_path)

        if isinstance(sub_app, Blueprint):
            app.register_blueprint(sub_app, url_prefix='/%s' % sub_app.name)
            # TODO: Check if it's necessary to import_models
            import_models(app, sub_app_name)
        else:
            app.logger.warn(("Failed to register {name} - "
                             "it does not match the registration pattern.").format(name=sub_app_name))

def general_menu():
    menu_items = list()
    blueprints = app.blueprints
    for k, v in blueprints.items():
        try:
            config = import_string('%s.config' % import_string(v.import_name).__package__)
        except ImportError, e:
            print e
        else:
            if hasattr(config, 'RUS_NAME'):
                menu_items.append(dict(module=v.name, name=config.RUS_NAME))
            else:
                menu_items.append(dict(module=v.name, name=v.name))

def create_app():
    app = Flask(__name__)
    app.config.from_object('envcfg.json.envision')

    for extension_name in extensions:
        extension = import_string(extension_name)
        extension.init_app(app)

    for blueprint_name in blueprints:
        blueprint = import_string(blueprint_name)
        app.register_blueprint(blueprint)

    return app