elif args.format == FORMAT_PRETTY:

        print 'Server response \n%s%s' % (

            error_prefix, json.dumps(json_data, indent=4, sort_keys=True)

        )

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))

        logging.info('Transferred file %s to %s', self.backup_file_name, cmd[4])

    def rm_file(self):

        logging.info('Removing file %s', self.backup_file_name)

        os.remove(os.path.join(self.backup_file_path, self.backup_file_name))

if __name__ == "__main__":

    repo_location = '/home/repo_path'

    backup_server = 'root@192.168.1.100:/backups/mercurial'

    rsa_key = '/home/id_rsa'

        # in light of possible future framework changes.

        self['errorpage.status_codes'] = [400, 401, 403, 404]

        # Disable transaction manager -- currently Kallithea takes care of transactions itself

        self['tm.enabled'] = False

base_config = KallitheaAppConfig()

# TODO still needed as long as we use pylonslib

sys.modules['pylons'] = tg

# DebugBar, a debug toolbar for TurboGears2.

    check_git_version()

    if str2bool(config.get('initial_repo_scan', True)):

        repo2db_mapper(ScmModel().repo_scan(repos_path),

                       remove_obsolete=False, install_git_hooks=False)

hooks.register('configure_new_app', setup_configuration)

def setup_application(app):

    config = app.config

    # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy

    if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):

        app = HttpsFixup(app, config)

    return app

hooks.register('before_config', setup_application)

__all__ = ['make_app']

# Use base_config to setup the necessary PasteDeploy application factory.

# make_base_app will wrap the TurboGears2 app with all the middleware it needs.

make_base_app = base_config.setup_tg_wsgi_app(load_environment)

def make_app_without_logging(global_conf, full_stack=True, **app_conf):

    """The core of make_app for use from gearbox commands (other than 'serve')"""

    return make_base_app(global_conf, full_stack=full_stack, **app_conf)

def make_app(global_conf, full_stack=True, **app_conf):

    """

    Set up Kallithea with the settings found in the PasteDeploy configuration

    file used.

    :param global_conf: The global settings for Kallithea (those

    # runs git and later git executes this hook.

    # Environ gets some additional info from kallithea system

    # like IP or username from basic-auth

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

    # runs git and later git executes this hook.

    # Environ gets some additional info from kallithea system

    # like IP or username from basic-auth

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

     :param clone_uri:

     :param fork_id:

     :param group_id:

     :param created_by:

    """

    return 0

CREATE_REPO_HOOK = _crrepohook

#==============================================================================

# PRE CREATE USER HOOK

#==============================================================================

    :param active:

    :param admin:

    :param created_by:

    """

    reason = 'allowed'

    return True, reason

PRE_CREATE_USER_HOOK = _pre_cruserhook

#==============================================================================

# POST CREATE USER HOOK

#==============================================================================

# this function will be executed after each user is created

      :param password:

      :param emails:

      :param inherit_default_permissions:

      :param created_by:

    """

    return 0

CREATE_USER_HOOK = _cruserhook

#==============================================================================

# POST DELETE REPOSITORY HOOK

#==============================================================================

     :param fork_id:

     :param group_id:

     :param deleted_by:

     :param deleted_on:

    """

    return 0

DELETE_REPO_HOOK = _dlrepohook

#==============================================================================

# POST DELETE USER HOOK

#==============================================================================

      :param password:

      :param emails:

      :param inherit_default_permissions:

      :param deleted_by:

    """

    return 0

DELETE_USER_HOOK = _dluserhook

#==============================================================================

# POST PUSH HOOK

#==============================================================================

      :param ip: ip of who pushed

      :param action: push

      :param repository: repository name

      :param pushed_revs: list of pushed revisions

    """

    return 0

PUSH_HOOK = _pushhook

#==============================================================================

# POST PULL HOOK

#==============================================================================

      :param username: name of user who pulled

      :param ip: ip of who pulled

      :param action: pull

      :param repository: repository name

    """

    return 0

PULL_HOOK = _pullhook

                  conditions=dict(method=["POST"], function=check_group))

        m.connect("delete_repo_group", "/repo_groups/{group_name:.*?}/delete",

                  action="delete", conditions=dict(method=["POST"],

                                                   function=check_group_skip_path))

    #ADMIN USER ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/users') as m:

        m.connect("new_user", "/users/new",

                  action="create", conditions=dict(method=["POST"]))

        m.connect("users", "/users",

        #EXTRAS USER GROUP ROUTES

        m.connect("edit_user_group_default_perms", "/user_groups/{id}/edit/default_perms",

                  action="edit_default_perms", conditions=dict(method=["GET"]))

        m.connect("edit_user_group_default_perms_update", "/user_groups/{id}/edit/default_perms",

                  action="update_default_perms", conditions=dict(method=["POST"]))

        m.connect("edit_user_group_perms", "/user_groups/{id}/edit/perms",

                  action="edit_perms", conditions=dict(method=["GET"]))

        m.connect("edit_user_group_perms_update", "/user_groups/{id}/edit/perms",

                  action="update_perms", conditions=dict(method=["POST"]))

        m.connect("edit_user_group_perms_delete", "/user_groups/{id}/edit/perms/delete",

                  action="delete_perms", conditions=dict(method=["POST"]))

        m.connect("edit_user_group_advanced", "/user_groups/{id}/edit/advanced",

                  action="edit_advanced", conditions=dict(method=["GET"]))

        m.connect("edit_user_group_members", "/user_groups/{id}/edit/members",

                  action="edit_members", conditions=dict(method=["GET"]))

    #ADMIN PERMISSIONS ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/permissions') as m:

        m.connect("admin_permissions", "/permissions",

                  action="permission_globals", conditions=dict(method=["POST"]))

        m.connect("admin_permissions", "/permissions",

        m.connect("admin_permissions_ips", "/permissions/ips",

                  action="permission_ips", conditions=dict(method=["GET"]))

        m.connect("admin_permissions_perms", "/permissions/perms",

                  action="permission_perms", conditions=dict(method=["GET"]))

    #ADMIN DEFAULTS ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/defaults') as m:

        m.connect('defaults', 'defaults',

                  action="index")

        m.connect('defaults_update', 'defaults/{id}/update',

                  action="create", conditions=dict(method=["POST"]))

        m.connect("gists", "/gists",

                  action="index", conditions=dict(method=["GET"]))

        m.connect("new_gist", "/gists/new",

                  action="new", conditions=dict(method=["GET"]))

        m.connect("gist_delete", "/gists/{gist_id}/delete",

                  action="delete", conditions=dict(method=["POST"]))

        m.connect("edit_gist", "/gists/{gist_id}/edit",

                  action="edit", conditions=dict(method=["GET", "POST"]))

        m.connect("edit_gist_check_revision", "/gists/{gist_id}/edit/check_revision",

                  action="check_revision", conditions=dict(method=["POST"]))

        m.connect("gist", "/gists/{gist_id}",

                  action="show", conditions=dict(method=["GET"]))

        m.connect("gist_rev", "/gists/{gist_id}/{revision}",

                  revision="tip",

                  action="show", conditions=dict(method=["GET"]))

        m.connect("formatted_gist", "/gists/{gist_id}/{revision}/{format}",

                 controller='admin/repos', action="create_repo_field",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect('delete_repo_fields', "/{repo_name:.*?}/settings/fields/{field_id}/delete",

                 controller='admin/repos', action="delete_repo_field",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_advanced", "/{repo_name:.*?}/settings/advanced",

                 controller='admin/repos', action="edit_advanced",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_advanced_locking", "/{repo_name:.*?}/settings/advanced/locking",

                 controller='admin/repos', action="edit_advanced_locking",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_advanced_fork", "/{repo_name:.*?}/settings/advanced/fork",

                 controller='admin/repos', action="edit_advanced_fork",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("update_repo_caches", "/{repo_name:.*?}/settings/caches",

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_remote_update", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["POST"], function=check_repo))

    Refer to documentation of Routes for details:

    https://routes.readthedocs.io/en/latest/generating.html#generation

    """

    def __call__(self, *args, **kwargs):

        return request.environ['routes.url'](*args, **kwargs)

    def current(self, *args, **kwargs):

        return request.environ['routes.url'].current(*args, **kwargs)

url = UrlGenerator()

    def check_revision(self, gist_id):

        c.gist = Gist.get_or_404(gist_id)

        last_rev = c.gist.scm_instance.get_changeset()

        success = True

        revision = request.POST.get('revision')

        if revision != last_rev.raw_id:

            log.error('Last revision %s is different than submitted %s',

                      revision, last_rev)

            # our gist has newer version than we

            success = False

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            except Exception:

                log.error(traceback.format_exc())

                        % form_result.get('username'), category='error')

        if update:

            raise HTTPFound(location='my_account')

        return htmlfill.render(

            render('admin/my_account/my_account.html'),

            defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('group_name'), category='error')

            parent_group_id = form_result['parent_group_id']

            #TODO: maybe we should get back to the main view, not the admin one

            raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))

        h.flash(_('Created repository group %s') % gr.group_name,

                category='success')

        )()

        try:

            form_result = repo_group_form.to_python(dict(request.POST))

            new_gr = RepoGroupModel().update(group_name, form_result)

            Session().commit()

                    % form_result['group_name'], category='success')

            # we now have new name !

            group_name = new_gr.group_name

            #TODO: in future action_logger(, '', '', '')

        except formencode.Invalid as errors:

            c.active = 'settings'

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('group_name'), category='error')

        raise HTTPFound(location=url('edit_repo_group', group_name=group_name))

    @HasRepoGroupPermissionLevelDecorator('admin')

    def delete(self, group_name):

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % repo_name, category='error')

        raise HTTPFound(location=url('edit_repo', repo_name=changed_name))

    @HasRepoPermissionLevelDecorator('admin')

    def delete(self, repo_name):

        repo_model = RepoModel()

        except Exception:

            h.flash(_('An error occurred during setting this'

                      ' repository in public journal'),

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced_fork(self, repo_name):

        """

        Mark given repository as a fork of another

        :param repo_name:

    @HasPermissionAnyDecorator('hg.admin')

    def settings_mapping(self):

        c.active = 'mapping'

        if request.POST:

            rm_obsolete = request.POST.get('destroy', False)

            install_git_hooks = request.POST.get('hooks', False)

            invalidate_cache = request.POST.get('invalidate', False)

            log.debug('rescanning repo location with destroy obsolete=%s, '

                      'install git hooks=%s and '

                      'overwrite git hooks=%s' % (rm_obsolete, install_git_hooks, overwrite_git_hooks))

            filesystem_repos = ScmModel().repo_scan()

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

        raise HTTPFound(location=url('users_groups'))

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def new(self, format='html'):

                errors=e,

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

        raise HTTPFound(location=url('edit_users_group', id=id))

    @HasUserGroupPermissionLevelDecorator('admin')

    def delete(self, id):

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'advanced'

        c.group_members_obj = sorted((x.user for x in c.user_group.members),

                                     key=lambda u: u.username.lower())

        return render('admin/user_groups/user_group_edit.html')

    @HasUserGroupPermissionLevelDecorator('admin')

    def edit_members(self, id):

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'members'

        c.group_members_obj = sorted((x.user for x in c.user_group.members),

                                     key=lambda u: u.username.lower())

                encoding="UTF-8",

                force_defaults=False)

        except UserCreationError as e:

            h.flash(e, 'error')

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('username'), category='error')

        raise HTTPFound(location=url('edit_user', id=user.user_id))

    def new(self, format='html'):

        c.default_extern_type = User.DEFAULT_AUTH_TYPE

        c.default_extern_name = ''

                errors=e,

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % form_result.get('username'), category='error')

        raise HTTPFound(location=url('edit_user', id=id))

    def delete(self, id):

        usr = User.get_or_404(id)

        try:

from tgext.routes import RoutedController

from kallithea.config.routing import make_map

from kallithea.lib.base import BaseController

from kallithea.controllers.error import ErrorController

from tg import config

# This is the main Kallithea entry point; TurboGears will forward all requests

# to an instance of 'controller.root.RootController' in the configured

# 'application' module (set by app_cfg.py).  Requests are forwarded to

# controllers based on the routing mapper that lives in this root instance.

# The mapper is configured using routes defined in routing.py.  This use of the

# 'mapper' attribute is a feature of tgext.routes, which is activated by

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                                     % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

    if is_windows:

        return hashlib.sha256(password).hexdigest()

    elif is_unix:

        import bcrypt

        return bcrypt.hashpw(safe_str(password), bcrypt.gensalt(10))

    else:

                        % __platform__)

def check_password(password, hashed):

    """

    Checks matching password with it's hashed value, runs different

            return bcrypt.checkpw(safe_str(password), safe_str(hashed))

        except ValueError as e:

            # bcrypt will throw ValueError 'Invalid hashed_password salt' on all password errors

            log.error('error from bcrypt checking password: %s', e)

            return False

    else:

                        % __platform__)

def _cached_perms_data(user_id, user_is_admin, user_inherit_default_permissions,

                       explicit, algo):

    RK = 'repositories'

    _grouped = [[x, list(y)] for x, y in

                itertools.groupby(user_perms_from_users_groups,

                                  lambda x:x.users_group)]

    for gr, perms in _grouped:

        # since user can be in multiple groups iterate over them and

        # select the lowest permissions first (more explicit)

        if not gr.inherit_default_permissions:

            # NEED TO IGNORE all configurable permissions and

            # replace them with explicitly set

            permissions[GLOBAL] = permissions[GLOBAL] \

                                            .difference(_configurable)

        for perm in perms:

            def __call__(self, *args, **kwargs):

                from kallithea.model import validators as v

                obj = getattr(v, self.validator_name)

                #log.debug('Initializing lazy formencode object: %s', obj)

                return LazyFormencode(obj, *args, **kwargs)

        class ProxyGet(object):

            def __getattribute__(self, name):

                return LazyCaller(name)

        return ProxyGet()

        # we failed to Auth because .auth() method didn't return the user

        if username:

            log.warning("User `%s` failed to authenticate against %s",

                        username, module)

    return None

def get_managed_fields(user):

    """return list of fields that are managed by the user's auth source, usually some of

    'username', 'firstname', 'lastname', 'email', 'active', 'password'

    """

    auth_plugins = get_auth_plugins()

    for plugin in auth_plugins:

    E.g. params_from_query(query.filter(Cls.foo==5).filter(Cls.bar==7)))

    would return [5, 7].

    """

    v = []

    def visit_bindparam(bind):

        if bind.key in query._params:

            value = query._params[bind.key]

        elif bind.callable:

            # lazyloader may dig a callable in here, intended

            # to late-evaluate params after autoflush is called.

            # convert to a scalar value.

                f_org(*args, **kwargs)

            finally:

                log.info('executed %s task', f_org.__name__)

        f_async.__name__ = f_org.__name__

        from kallithea.lib import celerypylons

        runner = celerypylons.task(ignore_result=True)(f_async)

        def f_wrapped(*args, **kwargs):

            t = runner.apply_async(args=args, kwargs=kwargs)

            log.info('executing task %s in async mode - id %s', f_org, t.task_id)

            return t

    else:

        def f_wrapped(*args, **kwargs):

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@celerylib.task

@celerylib.dbsession

def create_repo(form_data, cur_user):

    from kallithea.model.repo import RepoModel

    from kallithea.model.db import Setting

def celery_config(config):

    """Return Celery config object populated from relevant settings in a config dict, such as tg.config"""

    # Verify .ini file configuration has been loaded

    assert config['celery.imports'] == 'kallithea.lib.celerylib.tasks', 'Kallithea Celery configuration has not been loaded'

    celery_config = CeleryConfig()

    PREFIXES = """ADMINS BROKER CASSANDRA CELERYBEAT CELERYD CELERYMON CELERY EMAIL SERVER""".split()

    LIST_PARAMS = """CELERY_IMPORTS ADMINS ROUTES CELERY_ACCEPT_CONTENT""".split()

    for config_key, config_value in sorted(config.items()):

#==============================================================================

# OrderedDict - Python 2.7 could perhaps use collections.OrderedDict

#==============================================================================

# Python Software Foundation License

# XXX: it feels like using the class with "is" and "is not" instead of "==" and

# "!=" should be faster.

class _Nil(object):

    def __repr__(self):

        return "nil"

    def __ne__(self, other):

        if (isinstance(other, _Nil)):

            return False

        else:

            return NotImplemented

_nil = _Nil()

class OrderedDict(dict):

    """Ordered dict data structure, with O(1) complexity for dict operations

    that modify one element.

from gearbox.command import Command

class UpgradeDb(Command):

    '''(removed)'''

    deprecated = True

    def run(self, args):

    new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,

                                ignore_whitespace, context)

    return vcs_gitdiff

NEW_FILENODE = 1

DEL_FILENODE = 2

MOD_FILENODE = 3

RENAMED_FILENODE = 4

COPIED_FILENODE = 5

CHMOD_FILENODE = 6