return

        parts = parts.groupdict()

        time_params = {}

            if param:

                time_params[name] = int(param)

        return datetime.timedelta(**time_params)

        try:

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

                setting = Setting.create_or_update(k, v)

            Session().commit()

            h.flash(_('Default settings updated successfully'),

        import kallithea

        c.ini = kallithea.CONFIG

        server_info = Setting.get_server_info()

            setattr(c, key, val)

        return htmlfill.render(

        USER_SESSION_ATTR = 'apiuser'

        # get our arglist and check if we provided them as args

            if arg == USER_SESSION_ATTR:

                # USER_SESSION_ATTR is something translated from API key and

                # this is checked before so we don't need validate it

        tipbranch = None

        branches = []

            n = 'branch:%s:%s' % (abranch, branchrev)

            desc = abranch

            if branchrev == tiprev:

                log.debug('branch %r not found in %s', branch, repo)

        bookmarks = []

            n = 'book:%s:%s' % (bookmark, bookmarkrev)

            bookmarks.append((n, bookmark))

            if rev == bookmarkrev:

                selected = n

        tags = []

            if tag == 'tip':

                continue

            n = 'tag:%s:%s' % (tag, tagrev)

            self.is_default_user = False

        else:

            # copy non-confidential database fields from a `db.User` to this `AuthUser`.

                assert k not in ['api_keys', 'permissions']

                setattr(self, k, v)

            self.is_default_user = dbuser.is_default_user

        """

        Returns list of repositories you're an admin of

        """

                if x[1] == 'repository.admin']

    @property

        """

        Returns list of repository groups you're an admin of

        """

                if x[1] == 'group.admin']

    @property

        """

        Returns list of user groups you're an admin of

        """

                if x[1] == 'usergroup.admin']

    def __repr__(self):

                'new_lineno': '',

                'action':     'context',

                'line':       msg,

                  if _op not in [MOD_FILENODE]])

            _files.append({

            docutils_settings.update({'input_encoding': 'unicode',

                                      'report_level': 4})

                directives.register_directive(k, v)

            parts = publish_parts(source=source,

    @LazyProperty

    def tags(self):

        _tags = []

            if tsha == self.raw_id:

                _tags.append(tname)

        return _tags

            curdir = ''

            # initially extract things from root dir

                if curdir:

                    name = '/'.join((curdir, item))

                else:

                else:

                    curdir = dir

                dir_id = None

                    if dir == item:

                        dir_id = id

                if dir_id:

                    raise ChangesetError('%s have not been found' % curdir)

                # cache all items from the given traversed tree

                    if curdir:

                        name = '/'.join((curdir, item))

                    else:

        dirnodes = []

        filenodes = []

        als = self.repository.alias

            if path != '':

                obj_path = '/'.join((path, name))

            else:

            return []

        def get_tree_for_dir(tree, dirname):

                if name == dirname:

                    obj = self.repository._repo[id]

                    if isinstance(obj, objects.Tree):

    def _get_all_revisions2(self):

        # alternate implementation using dulwich

                    if type_ != b'T']

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

            return {}

        sortkey = lambda ctx: ctx[0]

        _branches = [(key, ascii_str(sha))

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

    @LazyProperty

        sortkey = lambda ctx: ctx[0]

        _tags = [(key, ascii_str(sha))

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

    def tag(self, name, user, revision=None, message=None, date=None,

                (b'refs/remotes/origin/', b'RH'),

                (b'refs/tags/', b'T')]

        _refs = {}

            for k, type_ in keys:

                if ref.startswith(k):

                    _key = ref[len(k):]

                    if n not in [b'HEAD']:

                        heads[n] = val

    def get_changeset(self, revision=None):

        """

            if os.path.dirname(d) == path]

        als = self.repository.alias

            #vals = url,rev,type

            loc = vals[0]

            cs = vals[1]

    code_list = []

    if text == '' and len(opts) == 1 and opts[0] == 'reset':

        return '\x1b[%sm' % RESET

        if k == 'fg':

            code_list.append(foreground[v])

        elif k == 'bg':

    code_list = []

    if text == '' and len(opts) == 1 and opts[0] == 'reset':

        return '\x1b[%sm' % RESET

        if k == 'fg':

            code_list.append(foreground[v])

        elif k == 'bg':

            # update with attributes from __json__

            if callable(_json_attr):

                _json_attr = _json_attr()

                d[k] = val

        return d

        repo = repo.scm_instance

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

        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

            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

        hist_l.append(tags_group)

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

            # CLEAN OUT ORG VALUE FROM NEW MEMBERS, and group them using

            new_perms_group = defaultdict(dict)

                if k.startswith('perm_new_member'):

                    del value[k]

                    _type, part = k.split('perm_new_member_')

                if new_member and new_perm and new_type:

                    perms_new.add((new_member, new_perm, new_type))

                if k.startswith('u_perm_') or k.startswith('g_perm_'):

                    member = k[7:]

                    t = {'u': 'user',

## original location of comments ... but the ones outside diff context remains here

<div class="comments inline-comments">

  %for f_path, lines in c.inline_comments:

      <div class="comments-list-chunk" data-f_path="${f_path}" data-line_no="${line_no}" data-target-id="${h.safeid(h.safe_unicode(f_path))}_${line_no}">

        %for co in comments:

            ${comment_block(co)}

        with open(os.path.join(FIXTURES, 'journal_dump.csv')) as f:

            for row in csv.DictReader(f):

                ul = UserLog()

                    v = safe_unicode(v)

                    if k == 'action_date':

                        v = strptime(v)

        assert doc_changeset not in default_branch_changesets

    def test_get_changeset_by_branch(self):

            assert sha == self.repo.get_changeset(branch).raw_id

    def test_get_changeset_by_tag(self):

            assert sha == self.repo.get_changeset(tag).raw_id

    def test_get_changeset_parents(self):

        Tests if hooks are installed in repository if they are missing.

        """

            if os.path.exists(hook_path):

                os.remove(hook_path)

        ScmModel().install_git_hooks(repo=self.repo)

            assert os.path.exists(hook_path)

    def test_kallithea_hooks_updated(self):

        Tests if hooks are updated if they are Kallithea hooks already.

        """

            with open(hook_path, "w") as f:

                f.write("KALLITHEA_HOOK_VER=0.0.0\nJUST_BOGUS")

        ScmModel().install_git_hooks(repo=self.repo)

            with open(hook_path) as f:

                assert "JUST_BOGUS" not in f.read()

        Tests if hooks are left untouched if they are not Kallithea hooks.

        """

            with open(hook_path, "w") as f:

                f.write("#!/bin/bash\n#CUSTOM_HOOK")

        ScmModel().install_git_hooks(repo=self.repo)

            with open(hook_path) as f:

                assert "CUSTOM_HOOK" in f.read()

        Tests if hooks are forcefully updated even though they are custom hooks.

        """

            with open(hook_path, "w") as f:

                f.write("#!/bin/bash\n#CUSTOM_HOOK")

        ScmModel().install_git_hooks(repo=self.repo, force_create=True)

            with open(hook_path) as f:

                assert "KALLITHEA_HOOK_VER" in f.read()