type=click.Path(dir_okay=False, exists=True, readable=True), required=True)

            @functools.wraps(annotated) # reuse meta data from the wrapped function so click can see other options

            def runtime_wrapper(config_file, *args, **kwargs):

                path_to_ini_file = os.path.realpath(config_file)

                config = paste.deploy.appconfig('config:' + path_to_ini_file)

                cp = configparser.ConfigParser(strict=False)

                cp.read_string(read_config(path_to_ini_file, strip_section_prefix=annotated.__name__))

                logging.config.fileConfig(cp,

                    {'__file__': path_to_ini_file, 'here': os.path.dirname(path_to_ini_file)})

                if needs_config_file:

                    annotated(*args, config=config, **kwargs)

                if config_file_initialize_app:

                    annotated(*args, **kwargs)

            return cli_command(runtime_wrapper)

        return annotator

    return cli_command

    Any extra arguments you pass to this command will be passed through to

    Celery. Use '--' before such extra arguments to avoid options to be parsed

    by this CLI command.

    """

    if not asbool(config.get('use_celery')):

        raise Exception('Please set use_celery = true in .ini config '

                        'file before running this command')

    kallithea.CELERY_APP.config_from_object(celery_app.make_celery_config(config))

    args = list(celery_args)

    # args[0] is generally ignored when prog_name is specified, but -h *needs* it to be 'worker' ... but will also suggest that users specify 'worker' explicitly

    if not args or args[0] != 'worker':

        args.insert(0, 'worker')

    # inline kallithea.CELERY_APP.start in order to allow specifying prog_name

    assert celery_command.params[0].name == 'app'

    celery_command.params[0].default = kallithea.CELERY_APP

    celery_command.main(args=args, prog_name='kallithea-cli celery-run -c CONFIG_FILE --')

    Create a light-weight environment for stand-alone scripts and return an UI and the

    db repository.

    Git hooks are executed as subprocess of Git while Kallithea is waiting, and

    they thus need enough info to be able to create an app environment and

    connect to the database.

    """

    extras = get_hook_environment()

    path_to_ini_file = extras['config']

    config = paste.deploy.appconfig('config:' + path_to_ini_file)

    #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging

    # fix if it's not a bare repo

    if repo_path.endswith(os.sep + '.git'):

        repo_path = repo_path[:-5]

    repo = db.Repository.get_by_full_path(repo_path)

    if not repo:

        raise OSError('Repository %s not found in database' % repo_path)

    return repo

        app = HttpsFixup(app, config)

    app = PermanentRepoUrl(app, config)

    # Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead

    if asbool(config.get('use_wsgi_wrapper')):

        app = RequestWrapper(app, config)

    return app

def make_app(global_conf, **app_conf):

    """

    Set up Kallithea with the settings found in the PasteDeploy configuration

    file used.

    :param global_conf: The global settings for Kallithea (those

        defined under the ``[DEFAULT]`` section).

    :return: The Kallithea application with all the relevant middleware

        loaded.

    This is the PasteDeploy factory for the Kallithea application.

    ``app_conf`` contains all the application-specific settings (those defined

from sqlalchemy import engine_from_config

import kallithea.config.application

from kallithea.lib.utils2 import get_crypt_password

from kallithea.model import db, meta

from kallithea.model.base import init_model

from kallithea.model.repo import RepoModel

from kallithea.tests.base import HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS

rel_path = dirname(dirname(dirname(dirname(os.path.abspath(__file__)))))

conf = appconfig('config:development.ini', relative_to=rel_path)

USER = TEST_USER_ADMIN_LOGIN

PASS = TEST_USER_ADMIN_PASS

HOST = 'server.local'

METHOD = 'pull'

DEBUG = True

log = logging.getLogger(__name__)

class Command(object):

    def __init__(self, cwd):