enable_downloads=Optional(False)):

        """

        Updates repo

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param name:

        :param owner:

        :param group:

        :param description:

        :param private:

        :param clone_uri:

        :param landing_rev:

        :param enable_statistics:

        :param enable_downloads:

        """

        repo = get_repo_or_error(repoid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoPermissionLevel('admin')(repo.repo_name):

                raise JSONRPCError('repository `%s` does not exist' % (repoid,))

            if (name != repo.repo_name and

                not HasPermissionAny('hg.create.repository')()

                raise JSONRPCError('no permission to create (or move) repositories')

            if not isinstance(owner, Optional):

                # forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only Kallithea admin can specify `owner` param'

                )

        updates = {}

        repo_group = group

        if not isinstance(repo_group, Optional):

            repo_group = get_repo_group_or_error(repo_group)

            repo_group = repo_group.group_id

        try:

            store_update(updates, name, 'repo_name')

            store_update(updates, repo_group, 'repo_group')

            store_update(updates, owner, 'owner')

            store_update(updates, description, 'repo_description')

            store_update(updates, private, 'repo_private')

            store_update(updates, clone_uri, 'clone_uri')

            store_update(updates, landing_rev, 'repo_landing_rev')

            store_update(updates, enable_statistics, 'repo_enable_statistics')

            store_update(updates, enable_downloads, 'repo_enable_downloads')

        pull_request_id = pull_request.pull_request_id

    else:

        pull_request_id = None

    status = request.POST.get('changeset_status')

    close_pr = request.POST.get('save_close')

    delete = request.POST.get('save_delete')

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

    line_no = request.POST.get('line')

    if (status or close_pr or delete) and (f_path or line_no):

        # status votes and closing is only possible in general comments

        raise HTTPBadRequest()

    if not allowed_to_change_status:

        if status or close_pr:

            h.flash(_('No permission to change status'), 'error')

            raise HTTPForbidden()

    if pull_request and delete == "delete":

        if (pull_request.owner_id == request.authuser.user_id or

            h.HasPermissionAny('hg.admin')() or

            h.HasRepoPermissionLevel('admin')(pull_request.org_repo.repo_name) or

            h.HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request %s') % pull_request_id,

                    category='success')

            return {

               'location': h.url('my_pullrequests'), # or repo pr list?

            }

            raise HTTPFound(location=h.url('my_pullrequests')) # or repo pr list?

        raise HTTPForbidden()

    text = request.POST.get('text', '').strip()

    comment = ChangesetCommentsModel().create(

        text=text,

        repo=c.db_repo.repo_id,

        author=request.authuser.user_id,

        revision=revision,

        pull_request=pull_request_id,

        f_path=f_path or None,

        line_no=line_no or None,

        status_change=ChangesetStatus.get_status_lbl(status) if status else None,

        closing_pr=close_pr,

    )

        following function as ``annotate_from_changeset_func``::

            def changeset_to_anchor(changeset):

                return '<a href="/changesets/%s/">%s</a>\n' % \

                       (changeset.id, changeset.id)

        :param annotate_from_changeset_func: see above

        :param order: (default: ``['ls', 'annotate', 'code']``); order of

          columns;

        :param options: standard pygment's HtmlFormatter options, there is

          extra option tough, ``headers``. For instance we can pass::

             formatter = AnnotateHtmlFormatter(filenode, headers={

                'ls': '#',

                'annotate': 'Annotate',

                'code': 'Code',

             })

        """

        super(AnnotateHtmlFormatter, self).__init__(**options)

        self.annotate_from_changeset_func = annotate_from_changeset_func

        self.order = order or ('ls', 'annotate', 'code')

        headers = options.pop('headers', None)

        if headers and not ('ls' in headers and 'annotate' in headers and

            raise ValueError("If headers option dict is specified it must "

                "all 'ls', 'annotate' and 'code' keys")

        self.headers = headers

        if isinstance(filenode, FileNode):

            self.filenode = filenode

        else:

            raise VCSError("This formatter expect FileNode parameter, not %r"

                % type(filenode))

    def annotate_from_changeset(self, changeset):

        """

        Returns full html line for single changeset per annotated line.

        """

        if self.annotate_from_changeset_func:

            return self.annotate_from_changeset_func(changeset)

        else:

            return ''.join((changeset.id, '\n'))

    def _wrap_tablelinenos(self, inner):

        dummyoutfile = StringIO.StringIO()

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

        class parsed_request(object):

            # See https://git-scm.com/book/en/v2/Git-Internals-Transfer-Protocols#_the_smart_protocol

            repo_name = safe_unicode(m.group(1).rstrip('/'))

            cmd = m.group(2)

            query_string = environ['QUERY_STRING']

            if cmd == 'info/refs' and query_string.startswith('service='):

                service = query_string.split('=', 1)[1]

                action = cmd_mapping.get(service)

            else:

                service = None

                action = cmd_mapping.get(cmd)

        return parsed_request

    def _make_app(self, parsed_request):

        """

        Return a pygrack wsgi application.

        """

        pygrack_app = make_wsgi_app(parsed_request.repo_name, self.basepath)

        def wrapper_app(environ, start_response):

            if (parsed_request.cmd == 'info/refs' and

                parsed_request.service == 'git-upload-pack'

                baseui = make_ui()

                repo = Repository.get_by_repo_name(parsed_request.repo_name)

                scm_repo = repo.scm_instance

                # Run hooks, like Mercurial outgoing.pull_logger does

                log_pull_action(ui=baseui, repo=scm_repo._repo)

            # Note: push hooks are handled by post-receive hook

            return pygrack_app(environ, start_response)

        return wrapper_app

        # page numbers and the end of the page range

        if self.last_page - rightmost_page > 1:

            text_ = '..'

            # Wrap in a SPAN tag if nolink_attr is set

            if self.dotdot_attr:

                text_ = HTML.span(c=text_, **self.dotdot_attr)

            nav_items.append(HTML.li(text_))

        # Create a link to the very last page (unless we are on the last

        # page or there would be no need to insert '..' spacers)

        if self.page != self.last_page and rightmost_page < self.last_page:

            nav_items.append(HTML.li(self._pagerlink(self.last_page, self.last_page)))

        #_page_link = url.current()

        #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))

        #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))

        return self.separator.join(nav_items)

    def pager(self, format='<ul class="pagination">$link_previous ~2~ $link_next</ul>', page_param='page', partial_param='partial',

        show_if_single_page=False, separator=' ', onclick=None,

        symbol_first='<<', symbol_last='>>',

        symbol_previous='<', symbol_next='>',

        link_attr=None,

        curpage_attr=None,

        self.curpage_attr = curpage_attr or {'class': 'active'}

        self.separator = separator

        self.pager_kwargs = kwargs

        self.page_param = page_param

        self.partial_param = partial_param

        self.onclick = onclick

        self.link_attr = link_attr or {'class': 'pager_link', 'rel': 'prerender'}

        self.dotdot_attr = dotdot_attr or {'class': 'pager_dotdot'}

        # Don't show navigator if there is no more than one page

        if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):

            return ''

        from string import Template

        # Replace ~...~ in token format by range of pages

        result = re.sub(r'~(\d+)~', self._range, format)

        # Interpolate '%' variables

        result = Template(result).safe_substitute({

            'first_page': self.first_page,

            'last_page': self.last_page,

            'page': self.page,

            'page_count': self.page_count,

            'items_per_page': self.items_per_page,

        future = True

    if future:

        prevdate = prevdate.replace(microsecond=0)

    # Get date parts deltas

    from dateutil import relativedelta

    for part in order:

        d = relativedelta.relativedelta(now, prevdate)

        deltas[part] = getattr(d, part + 's')

    # Fix negative offsets (there is 1 second between 10:59:59 and 11:00:00,

    # not 1 hour, -59 minutes and -59 seconds)

    for num, length in [(5, 60), (4, 60), (3, 24)]:  # seconds, minutes, hours

        part = order[num]

        carry_part = order[num - 1]

        if deltas[part] < 0:

            deltas[part] += length

            deltas[carry_part] -= 1

    # Same thing for days except that the increment depends on the (variable)

    # number of days in the month

    month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

    if deltas['day'] < 0:

        if prevdate.month == 2 and (prevdate.year % 4 == 0 and

            deltas['day'] += 29

        else:

            deltas['day'] += month_lengths[prevdate.month - 1]

        deltas['month'] -= 1

    if deltas['month'] < 0:

        deltas['month'] += 12

        deltas['year'] -= 1

    # In short version, we want nicer handling of ages of more than a year

    if show_short_version:

        if deltas['year'] == 1:

            # ages between 1 and 2 years: show as months

            deltas['month'] += 12

            deltas['year'] = 0

        if deltas['year'] >= 2:

            # ages 2+ years: round

            if deltas['month'] > 6:

                deltas['year'] += 1

                deltas['month'] = 0

    # Format the result

    fmt_funcs = {

                content = node.content

            blob = objects.Blob.from_string(content)

            node_path = node.name.encode(ENCODING)

            if dirnames:

                # If there are trees which should be created we need to build

                # them now (in reverse order)

                reversed_dirnames = list(reversed(dirnames))

                curtree = objects.Tree()

                curtree[node_path] = node.mode, blob.id

                new_trees.append(curtree)

                for dirname in reversed_dirnames[:-1]:

                    newtree = objects.Tree()

                    #newtree.add(stat.S_IFDIR, dirname, curtree.id)

                    newtree[dirname] = stat.S_IFDIR, curtree.id

                    new_trees.append(newtree)

                    curtree = newtree

                parent[reversed_dirnames[-1]] = stat.S_IFDIR, curtree.id

            else:

                parent.add(name=node_path, mode=node.mode, hexsha=blob.id)

            new_trees.append(parent)

            # Update ancestors

            for parent, tree, path in reversed([(a[1], b[1], b[0]) for a, b in

                parent[path] = stat.S_IFDIR, tree.id

                object_store.add_object(tree)

            object_store.add_object(blob)

            for tree in new_trees:

                object_store.add_object(tree)

        for node in self.removed:

            paths = node.path.split('/')

            tree = commit_tree

            trees = [tree]

            # Traverse deep into the forest...

            for path in paths:

                try:

                    obj = self.repository._repo[tree[path][1]]

                    if isinstance(obj, objects.Tree):

                        trees.append(obj)

                        tree = obj

                except KeyError:

                    break

            # Cut down the blob and all rotten trees on the way back...

            for path, tree in reversed(zip(paths, trees)):

                del tree[path]

                if tree:

                    # This tree still has elements - don't remove it or any

        following function as ``annotate_from_changeset_func``::

            def changeset_to_anchor(changeset):

                return '<a href="/changesets/%s/">%s</a>\n' % \

                       (changeset.id, changeset.id)

        :param annotate_from_changeset_func: see above

        :param order: (default: ``['ls', 'annotate', 'code']``); order of

          columns;

        :param options: standard pygment's HtmlFormatter options, there is

          extra option tough, ``headers``. For instance we can pass::

             formatter = AnnotateHtmlFormatter(filenode, headers={

                'ls': '#',

                'annotate': 'Annotate',

                'code': 'Code',

             })

        """

        super(AnnotateHtmlFormatter, self).__init__(**options)

        self.annotate_from_changeset_func = annotate_from_changeset_func

        self.order = order or ('ls', 'annotate', 'code')

        headers = options.pop('headers', None)

        if headers and not ('ls' in headers and 'annotate' in headers and

            raise ValueError("If headers option dict is specified it must "

                "all 'ls', 'annotate' and 'code' keys")

        self.headers = headers

        if isinstance(filenode, FileNode):

            self.filenode = filenode

        else:

            raise VCSError("This formatter expect FileNode parameter, not %r"

                % type(filenode))

    def annotate_from_changeset(self, changeset):

        """

        Returns full html line for single changeset per annotated line.

        """

        if self.annotate_from_changeset_func:

            return self.annotate_from_changeset_func(changeset)

        else:

            return ''.join((changeset.id, '\n'))

    def _wrap_tablelinenos(self, inner):

        dummyoutfile = StringIO.StringIO()

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1