"""

        self._get_filectx(path)

        from dulwich.walk import Walker

        include = [self.id]

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

                        paths=[path], max_entries=1)

        return [self.repository.get_changeset(sha)

                for sha in (x.commit.id 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.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, se = self.repository.run_git_command(cmd)

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

            ln_no = i + 1

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

            yield (ln_no, sha, lambda: 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>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        allowed_kinds = settings.ARCHIVE_SPECS.keys()

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

                'of %s', allowed_kinds)

        if prefix is None:

            prefix = '%s-%s' % (self.repository.name, self.short_id)

        elif prefix.startswith('/'):

            raise VCSError("Prefix cannot start with leading slash")

        elif prefix.strip() == '':

            raise VCSError("Prefix cannot be empty")

        if kind == 'zip':

            frmt = 'zip'

        else:

            frmt = 'tar'

        _git_path = settings.GIT_EXECUTABLE_PATH

        cmd = '%s archive --format=%s --prefix=%s/ %s' % (_git_path,

                                                frmt, prefix, self.raw_id)

        if kind == 'tgz':

            cmd += ' | gzip -9'

        elif kind == 'tbz2':

            cmd += ' | bzip2 -9'

        if stream is None:

            raise VCSError('You need to pass in a valid stream for filling'

                           ' with archival data')

        popen = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True,

                      cwd=self.repository.path)

        buffer_size = 1024 * 8

        chunk = popen.stdout.read(buffer_size)

        while chunk:

            stream.write(chunk)

            chunk = popen.stdout.read(buffer_size)

        # Make sure all descriptors would be read

        popen.communicate()

    def get_nodes(self, path):

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

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

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

        path = self._fix_path(path)

        id = self._get_id_for_path(path)

        tree = self.repository._repo[id]

        dirnodes = []

        filenodes = []

        als = self.repository.alias

        for name, stat, id in tree.iteritems():

            if objects.S_ISGITLINK(stat):

                                              alias=als))

                continue

            obj = self.repository._repo.get_object(id)

            if obj_path not in self._stat_modes:

                self._stat_modes[obj_path] = stat

            if isinstance(obj, objects.Tree):

                dirnodes.append(DirNode(obj_path, changeset=self))

            elif isinstance(obj, objects.Blob):

                filenodes.append(FileNode(obj_path, changeset=self, mode=stat))

            else:

                raise ChangesetError("Requested object should be Tree "

                                     "or Blob, is %r" % type(obj))

        nodes = dirnodes + filenodes

        for node in nodes:

            if node.path not in self.nodes:

                self.nodes[node.path] = node

        nodes.sort()

        return nodes

    def get_node(self, path):

        if isinstance(path, unicode):

            path = path.encode('utf-8')

        path = self._fix_path(path)

        if path not in self.nodes:

            try:

                id_ = self._get_id_for_path(path)

            except ChangesetError:

                raise NodeDoesNotExistError("Cannot find one of parents' "

                    "directories for a given path: %s" % path)

            _GL = lambda m: m and objects.S_ISGITLINK(m)

            if _GL(self._stat_modes.get(path)):

                tree = self.repository._repo[self._tree_id]

                cf = ConfigFile.from_file(BytesIO(self.repository._repo.get_object(tree['.gitmodules'][1]).data))

                url = cf.get(('submodule', path), 'url')

                node = SubModuleNode(path, url=url, changeset=id_,

                                     alias=self.repository.alias)

            else:

                obj = self.repository._repo.get_object(id_)

                if isinstance(obj, objects.Tree):

                    if path == '':

                        node = RootNode(changeset=self)

                    else:

                        node = DirNode(path, changeset=self)

                    node._tree = obj

                elif isinstance(obj, objects.Blob):

                    node = FileNode(path, changeset=self)

                    node._blob = obj

                else:

                    raise NodeDoesNotExistError("There is no file nor directory "

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

                        % (path, self.short_id))

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        Gets a fast accessible file changes for given changeset

        """

        added, modified, deleted = self._changes_cache

        return list(added.union(modified).union(deleted))

    @LazyProperty

    def _diff_name_status(self):

        output = []

        for parent in self.parents:

            cmd = ['diff', '--name-status', parent.raw_id, self.raw_id,

                   '--encoding=utf8']

            so, se = self.repository.run_git_command(cmd)

            output.append(so.strip())

        return '\n'.join(output)

    @LazyProperty

    def _changes_cache(self):

        added = set()

        modified = set()

        deleted = set()

        _r = self.repository._repo

        parents = self.parents

        if not self.parents:

            parents = [EmptyChangeset()]

        for parent in parents:

            if isinstance(parent, EmptyChangeset):

                oid = None

            else:

                oid = _r[parent.raw_id].tree

            changes = _r.object_store.tree_changes(oid, _r[self.raw_id].tree)

            for (oldpath, newpath), (_, _), (_, _) in changes:

                if newpath and oldpath:

                    modified.add(newpath)

                elif newpath and not oldpath:

                    added.add(newpath)

                elif not newpath and oldpath:

                    deleted.add(oldpath)

        return added, modified, deleted