"""

        try:

            with open(self._conf_name, 'rb') as conf:

        except IOError as e:

            #sys.stderr.write(str(e) + '\n')

            pass

        )

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))

        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'

        # 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

        repo2db_mapper(ScmModel().repo_scan(repos_path),

                       remove_obsolete=False, install_git_hooks=False)

hooks.register('configure_new_app', setup_configuration)

        app = HttpsFixup(app, config)

    return app

hooks.register('before_config', setup_application)

# 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

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

     :param created_by:

    """

    return 0

CREATE_REPO_HOOK = _crrepohook

    """

    reason = 'allowed'

    return True, reason

PRE_CREATE_USER_HOOK = _pre_cruserhook

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

      :param created_by:

    """

    return 0

CREATE_USER_HOOK = _cruserhook

     :param deleted_on:

    """

    return 0

DELETE_REPO_HOOK = _dlrepohook

      :param deleted_by:

    """

    return 0

DELETE_USER_HOOK = _dluserhook

      :param pushed_revs: list of pushed revisions

    """

    return 0

PUSH_HOOK = _pushhook

      :param repository: repository name

    """

    return 0

PULL_HOOK = _pullhook

    # CUSTOM ROUTES HERE

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

    rmap.connect('home', '/', controller='home', action='index')

    rmap.connect('about', '/about', controller='home', action='about')

    rmap.connect('repo_switcher_data', '/_repos', controller='home',

    rmap.connect('kallithea_project_url', "https://kallithea-scm.org/", _static=True)

    rmap.connect('issues_url', 'https://bitbucket.org/conservancy/kallithea/issues', _static=True)

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/repos') as m:

        m.connect("repos", "/repos",

        m.connect("delete_repo", "/repos/{repo_name:.*?}/delete",

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/repo_groups') as m:

        m.connect("repos_groups", "/repo_groups",

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

                                                 function=check_group))

        m.connect("edit_repo_group", "/repo_groups/{group_name:.*?}/edit",

                  action="edit",

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

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

                                                   function=check_group_skip_path))

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/users') as m:

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

        m.connect("edit_user", "/users/{id}/edit",

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

        m.connect("edit_user_advanced", "/users/{id}/edit/advanced",

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

        m.connect("edit_user_ips_delete", "/users/{id}/edit/ips/delete",

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/user_groups') as m:

        m.connect("users_groups", "/user_groups",

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

                  function=check_user_group)

        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",

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

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/permissions') as m:

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

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

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/defaults') as m:

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

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

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

    rmap.connect('auth_settings', '%s/auth' % ADMIN_PREFIX,

                 controller='admin/auth_settings', action='auth_settings',

                 conditions=dict(method=["POST"]))

    rmap.connect('auth_home', '%s/auth' % ADMIN_PREFIX,

                 controller='admin/auth_settings')

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/settings') as m:

        m.connect("admin_settings", "/settings",

        m.connect("admin_settings_system_update", "/settings/system/updates",

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/my_account') as m:

        m.connect("my_account_api_keys_delete", "/my_account/api_keys/delete",

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/notifications') as m:

        m.connect("notifications", "/notifications",

        m.connect("formatted_notification", "/notifications/{notification_id}.{format}",

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/gists') as m:

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

        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",

        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"]))

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/admin') as m:

        m.connect('admin_home', '', action='index')

                        action='_dispatch') as m:

        m.connect('api', '/api')

    rmap.connect('journal', '%s/journal' % ADMIN_PREFIX,

                 controller='journal', action='index')

    rmap.connect('journal_rss', '%s/journal/rss' % ADMIN_PREFIX,

                 controller='journal', action='toggle_following',

                 conditions=dict(method=["POST"]))

    rmap.connect('search', '%s/search' % ADMIN_PREFIX, controller='search',)

    rmap.connect('search_repo_admin', '%s/search/{repo_name:.*}' % ADMIN_PREFIX,

                 controller='search',

                 conditions=dict(function=check_repo),

                 )

    rmap.connect('authentication_token', '%s/authentication_token' % ADMIN_PREFIX, controller='login', action='authentication_token')

    rmap.connect('login_home', '%s/login' % ADMIN_PREFIX, controller='login')

    rmap.connect('logout_home', '%s/logout' % ADMIN_PREFIX, controller='login',

                 '%s/password_reset_confirmation' % ADMIN_PREFIX,

                 controller='login', action='password_reset_confirmation')

    rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',

                controller='feed', action='rss',

                conditions=dict(function=check_repo))

                 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))

                 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))

                 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))

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

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

    rmap.connect('raw_changeset_home_depraced',

                 '/{repo_name:.*?}/raw-changeset/{revision}',

                 controller='changeset', action='changeset_raw',

    """

    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 wildcard_handler(col, wc_term):

        if wc_term.startswith('*') and not wc_term.endswith('*'):

            wc_term = remove_prefix(wc_term, prefix='*')

            return func.lower(col).endswith(func.lower(wc_term))

        elif wc_term.startswith('*') and wc_term.endswith('*'):

            wc_term = remove_prefix(wc_term, prefix='*')

            wc_term = remove_suffix(wc_term, suffix='*')

            return func.lower(col).contains(func.lower(wc_term))

            field = getattr(UserLog, field)

        log.debug('filter field: %s val=>%s', field, val)

        if isinstance(term, query.Wildcard):

            return wildcard_handler(field, val)

        elif isinstance(term, query.Prefix):

                .options(joinedload(UserLog.user)) \

                .options(joinedload(UserLog.repository))

        c.search_term = request.GET.get('filter')

        users_log = _journal_filter(users_log, c.search_term)

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

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

            filename = form_result['filename'] or Gist.DEFAULT_FILENAME

            nodes = {

                filename: {

        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)

                    force_defaults=False)

            except Exception:

                log.error(traceback.format_exc())

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

        if update:

            raise HTTPFound(location='my_account')

        c.active = 'repos'

        self.__load_data()

        c.data = self._load_my_repos_data()

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

        c.active = 'watched'

        self.__load_data()

        c.data = self._load_my_repos_data(watched=True)

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

                copy_permissions=form_result['group_copy_permissions']

            )

            Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/repo_groups/repo_group_add.html'),

                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']

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

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

                category='success')

    def new(self):

        if HasPermissionAny('hg.admin')('group create'):

            pass

        else:

            # we pass in parent group into creation form, thus we know

        # TODO: kill allow_empty_group - it is only used for redundant form validation!

        if HasPermissionAny('hg.admin')('group edit'):

            allow_empty_group = True

        elif not c.repo_group.parent_group:

            allow_empty_group = True

            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

        except formencode.Invalid as errors:

            c.active = 'settings'

            return htmlfill.render(

                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))

            Session().commit()

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

                    category='success')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during deletion of repository group %s')

                                             form_result['perms_new'],

                                             form_result['perms_updates'],

                                             recursive)

        #action_logger(request.authuser, 'admin_changed_repo_permissions',

        #              repo_name, request.ip_addr)

        Session().commit()

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,

                                                   admin=True,

                                                   super_user_actions=True)

        c.data = repos_data

        return render('admin/repos/repos.html')

        except Exception:

            log.error(traceback.format_exc())

                    % repo_name, category='error')

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

        form = RepoPermsForm()().to_python(request.POST)

        RepoModel()._update_permissions(repo_name, form['perms_new'],

                                        form['perms_updates'])

        #action_logger(request.authuser, 'admin_changed_repo_permissions',

        #              repo_name, request.ip_addr)

        Session().commit()

                RepoModel().revoke_user_group_permission(

                    repo=repo_name, group_name=obj_id

                )

            #action_logger(request.authuser, 'admin_revoked_repo_permissions',

            #              repo_name, request.ip_addr)

            Session().commit()

                    category='error')

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

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced_fork(self, repo_name):

        """

                    sett = Ui.get_by_key('paths', '/')

                    sett.ui_value = form_result['paths_root_path']

                sett = Ui.get_by_key('hooks', Ui.HOOK_UPDATE)

                sett.ui_active = form_result['hooks_changegroup_update']

        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 '

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

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

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

                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))

        except RepoGroupAssignmentError:

            h.flash(_('Target group cannot be the same'), category='error')

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

        #action_logger(request.authuser, 'admin_changed_repo_permissions',

        #              repo_name, request.ip_addr)

        Session().commit()

                                     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)

            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))

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

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

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

                try:

                    collection = tip_cs.get_file_history(f_path)

                except (NodeDoesNotExistError, ChangesetError):

                    try:

                        cs = self.__get_cs(revision, repo_name)

                        collection = cs.get_file_history(f_path)

        ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))

    else:

        _ln_ctx = filter(lambda k: k.startswith('C'), GET)

        if ln_ctx:

            ln_ctx = [ln_ctx]

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.fulldiff = fulldiff = request.GET.get('fulldiff')

        rev_range = revision.split('...')[:2]

        enable_comments = True

        c.cs_repo = c.db_repo

                file_diff_data.append(('', None, None, None, diff, None))

            c.changes[changeset.raw_id] = (cs1, cs2, file_diff_data)

        c.comments = [com for com_id, com in sorted(comments.items())]

        # count inline comments

            other_changesets = []

        elif alias == 'hg':

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   other_repo.path,

                # all ancestors of other_rev will be in other_repo and

                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot

            else:

                hgrepo = other_repo._repo

    def __get_desc(self, cs):

        desc_msg = [(_('%s committed on %s')

                     % (h.person(cs.author), h.fmt_date(cs.date))) + '<br/>']