return choices, hist_l

    def _get_git_hook_interpreter(self):

        """Return a suitable interpreter for Git hooks.

        Return a suitable string to be written in the POSIX #! shebang line for

        Git hook scripts so they invoke Kallithea code with the right Python

        interpreter and in the right environment.

        """

        # Note: sys.executable might not point at a usable Python interpreter. For

        # example, when using uwsgi, it will point at the uwsgi program itself.

        # FIXME This may not work on Windows and may need a shell wrapper script.

        return (kallithea.CONFIG.get('git_hook_interpreter')

                or sys.executable

                or '/usr/bin/env python2')

    def install_git_hooks(self, repo, force_create=False):

        """

        Creates a kallithea hook inside a git repository

        :param repo: Instance of VCS repo

        :param force_create: Create even if same name hook exists

        """

        loc = os.path.join(repo.path, 'hooks')

        if not repo.bare:

            loc = os.path.join(repo.path, '.git', 'hooks')

        if not os.path.isdir(loc):

            os.makedirs(loc)

        tmpl_post = "#!%s\n" % self._get_git_hook_interpreter()

        tmpl_post += pkg_resources.resource_string(

            'kallithea', os.path.join('config', 'post_receive_tmpl.py')

        )

        tmpl_pre = "#!%s\n" % self._get_git_hook_interpreter()

        tmpl_pre += pkg_resources.resource_string(

            'kallithea', os.path.join('config', 'pre_receive_tmpl.py')

        )

        for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:

            _hook_file = os.path.join(loc, '%s-receive' % h_type)

            has_hook = False

            log.debug('Installing git hook in repo %s', repo)

            if os.path.exists(_hook_file):

                # let's take a look at this hook, maybe it's kallithea ?

                log.debug('hook exists, checking if it is from kallithea')

                with open(_hook_file, 'rb') as f:

                    data = f.read()

                    if matches:

                        try:

                            ver = matches.groups()[0]

                            has_hook = True

                        except Exception:

                            log.error(traceback.format_exc())

            else:

                # there is no hook in this dir, so we want to create one

                has_hook = True

            if has_hook or force_create:

                log.debug('writing %s hook file !', h_type)

                try:

                    with open(_hook_file, 'wb') as f:

                        tmpl = tmpl.replace('_TMPL_', kallithea.__version__)

                        f.write(tmpl)

                    os.chmod(_hook_file, 0o755)

                except IOError as e:

                    log.error('error writing %s: %s', _hook_file, e)

            else:

                log.debug('skipping writing hook file')

def AvailableRepoGroupChoices(top_perms, repo_group_perm_level, extras=()):

    """Return group_id,string tuples with choices for all the repo groups where

    the user has the necessary permissions.

    Top level is -1.

    """

    groups = RepoGroup.query().all()

    if HasPermissionAny('hg.admin')('available repo groups'):

        groups.append(None)

    else:

        groups = list(RepoGroupList(groups, perm_level=repo_group_perm_level))

        if top_perms and HasPermissionAny(*top_perms)('available repo groups'):

            groups.append(None)

        for extra in extras:

            if not any(rg == extra for rg in groups):

                groups.append(extra)

    return RepoGroup.groups_choices(groups=groups)