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

                # cache all items from the given traversed tree

                for item, stat, id in tree.items():

                    name = safe_str(item)

                    if curdir:

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

                    self._paths[name] = id

                    self._stat_modes[name] = stat

            if path not in self._paths:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path '%s' at revision %s"

                    % (path, self.short_id))

        return self._paths[path]

    def _get_kind(self, path):

        obj = self.repository._repo[self._get_id_for_path(path)]

        if isinstance(obj, objects.Blob):

            return NodeKind.FILE

        elif isinstance(obj, objects.Tree):

            return NodeKind.DIR

    def _get_filectx(self, path):

        path = path.rstrip('/')

        if self._get_kind(path) != NodeKind.FILE:

            raise ChangesetError("File does not exist for revision %s at "

                " '%s'" % (self.raw_id, path))

        return path

    def _get_file_nodes(self):

        return chain(*(t[2] for t in self.walk()))

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(ascii_str(parent_id))

                for parent_id in self._commit.parents]

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        rev_filter = settings.GIT_REV_FILTER

        so = self.repository.run_git_command(

            ['rev-list', rev_filter, '--children']

        )

        return [

            self.repository.get_changeset(cs)

            for parts in (l.split(' ') for l in so.splitlines())

            if parts[0] == self.raw_id

            for cs in parts[1:]

        ]

    def next(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        cs = self

        while True:

            try:

                next_ = cs.revision + 1

                next_rev = cs.repository.revisions[next_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = cs.repository.get_changeset(next_rev)

            if not branch or branch == cs.branch:

                return cs

    def prev(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        cs = self

        while True:

            try:

                prev_ = cs.revision - 1

                if prev_ < 0:

                    raise IndexError

                prev_rev = cs.repository.revisions[prev_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = cs.repository.get_changeset(prev_rev)

            if not branch or branch == cs.branch:

                return cs

    def diff(self, ignore_whitespace=True, context=3):

        # Only used to feed diffstat

        rev1 = self.parents[0] if self.parents else self.repository.EMPTY_CHANGESET

        rev2 = self

                                    ignore_whitespace=ignore_whitespace,

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        # ensure path is traversed

        self._get_id_for_path(path)

        return self._stat_modes[path]

    def get_file_content(self, path):

        """

        Returns content of the file at given ``path``.

        """

        id = self._get_id_for_path(path)

        blob = self.repository._repo[id]

        return blob.as_pretty_string()

    def get_file_size(self, path):

        """

        Returns size of the file at given ``path``.

        """

        id = self._get_id_for_path(path)

        blob = self.repository._repo[id]

        return blob.raw_length()

    def get_file_changeset(self, path):

        """

        Returns last commit of the file at the given ``path``.

        """

        return self.get_file_history(path, limit=1)[0]

    def get_file_history(self, path, limit=None):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        TODO: This function now uses os underlying 'git' and 'grep' commands

        which is generally not good. Should be replaced with algorithm

        iterating commits.

        """

        self._get_filectx(path)

        if limit is not None:

            cmd = ['log', '-n', str(safe_int(limit, 0)),

                   '--pretty=format:%H', '-s', self.raw_id, '--', path]

        else:

            cmd = ['log',

                   '--pretty=format:%H', '-s', self.raw_id, '--', path]

        so = self.repository.run_git_command(cmd)

        ids = re.findall(r'[0-9a-fA-F]{40}', so)

        return [self.repository.get_changeset(sha) for sha in ids]

    def get_file_history_2(self, path):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        self._get_filectx(path)

        from dulwich.walk import Walker

        include = [self.raw_id]

        walker = Walker(self.repository._repo.object_store, include,

                        paths=[path], max_entries=1)

        return [self.repository.get_changeset(ascii_str(x.commit.id.decode))

                for x in walker]

    def get_file_annotate(self, path):

        """

        Returns a generator of four element tuples with

            lineno, sha, changeset lazy loader and line

        """

        # TODO: This function now uses os underlying 'git' command which is

        # generally not good. Should be replaced with algorithm iterating

        # commits.

        cmd = ['blame', '-l', '--root', '-r', self.raw_id, '--', path]

        # -l     ==> outputs long shas (and we need all 40 characters)

        # --root ==> doesn't put '^' character for boundaries

        # -r sha ==> blames for the given revision

        so = self.repository.run_git_command(cmd)

        for i, blame_line in enumerate(so.split('\n')[:-1]):

            sha, line = re.split(r' ', blame_line, 1)

            yield (i + 1, sha, lambda sha=sha: self.repository.get_changeset(sha), line)

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

            (``repo-tip.<KIND>``).