committer = user.full_contact

        author = safe_unicode(author) if author else committer

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

            imc.remove(FileNode(path, content=content))

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

        else:

            self.mark_for_invalidation(repo.repo_name)

        return tip

    def get_unread_journal(self):

        return UserLog.query().count()

    def get_repo_landing_revs(self, repo=None):

        """

        Generates select option with tags branches and bookmarks (for hg only)

        grouped by type

        :param repo:

        """

        hist_l = []

        choices = []

        repo = self.__get_repo(repo)

        choices.append('rev:tip')

        if repo is None:

            return choices, hist_l

        repo = repo.scm_instance

        branches_group = ([(u'branch:%s' % k, k) for k, v in

                           repo.branches.iteritems()], _("Branches"))

        hist_l.append(branches_group)

        choices.extend([x[0] for x in branches_group[0]])

        if repo.alias == 'hg':

            bookmarks_group = ([(u'book:%s' % k, k) for k, v in

                                repo.bookmarks.iteritems()], _("Bookmarks"))

            hist_l.append(bookmarks_group)

            choices.extend([x[0] for x in bookmarks_group[0]])

        tags_group = ([(u'tag:%s' % k, k) for k, v in

                       repo.tags.iteritems()], _("Tags"))

        hist_l.append(tags_group)

        choices.extend([x[0] for x in tags_group[0]])

        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: