@LazyProperty

    def tags(self):

        _tags = []

        for tname, tsha in self.repository.tags.items():

            if tsha == self.raw_id:

                _tags.append(tname)

        return _tags

    @LazyProperty

    def branch(self):

        # Note: This function will return one branch name for the changeset -

        # that might not make sense in Git where branches() is a better match

        # for the basic model

        heads = self.repository._heads(reverse=False)

        ref = heads.get(self._commit.id)

        if ref:

            return safe_str(ref)

    @LazyProperty

    def branches(self):

        heads = self.repository._heads(reverse=True)

        return [safe_str(b) for b in heads if heads[b] == self._commit.id] # FIXME: Inefficient ... and returning None!

    def _get_id_for_path(self, path):

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

        if path not in self._paths:

            path = path.strip('/')

            # set root tree

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

            if path == '':

                self._paths[''] = tree.id

                return tree.id

            splitted = path.split('/')

            dirs, name = splitted[:-1], splitted[-1]

            curdir = ''

            # initially extract things from root dir

            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

            for dir in dirs:

                if curdir:

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

                else:

                    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):

        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']

        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):

        """

        Returns combined ``DirNode`` and ``FileNode`` objects list representing

        state of changeset at the given ``path``. If node at the given ``path``

        is not instance of ``DirNode``, ChangesetError would be raised.

        """

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

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

                " '%s'" % (self.revision, 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.items():

            obj_path = safe_str(name)

            if path != '':

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

            if objects.S_ISGITLINK(stat):

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

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

                url = ascii_str(cf.get(('submodule', obj_path), 'url'))

                dirnodes.append(SubModuleNode(obj_path, url=url, changeset=ascii_str(id),

                                              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):

        """

        Returns ``Node`` object from the given ``path``. If there is no node at

        the given ``path``, ``ChangesetError`` would be raised.

        """

        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[b'.gitmodules'][1]).data))

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

                node = SubModuleNode(path, url=url, changeset=ascii_str(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):

    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.repository.revisions.index(cs.raw_id) - 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):

        # Only used to feed diffstat

        return b''.join(self._ctx.diff())

            path = path.rstrip('/')

        if path in self._file_paths:

            return NodeKind.FILE

        elif path in self._dir_paths:

            return NodeKind.DIR

        else:

            raise ChangesetError("Node does not exist at the given path '%s'"

                % (path))

    def _get_filectx(self, path):

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

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

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

        return self._ctx.filectx(safe_bytes(path))

    def _extract_submodules(self):

        """

        returns a dictionary with submodule information from substate file

        of hg repository

        """

        return self._ctx.substate

    def get_file_mode(self, path):

        """

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

        """

        fctx = self._get_filectx(path)

        if b'x' in fctx.flags():

            return 0o100755

        else:

            return 0o100644

    def get_file_content(self, path):

        """

        if stream is None:

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

                           ' with archival data')

        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")

        mercurial.archival.archive(self.repository._repo, stream, ascii_bytes(self.raw_id),

                         safe_bytes(kind), prefix=safe_bytes(prefix), subrepos=subrepos)

    def get_nodes(self, path):

        """

        Returns combined ``DirNode`` and ``FileNode`` objects list representing

        state of changeset at the given ``path``. If node at the given ``path``

        is not instance of ``DirNode``, ChangesetError would be raised.

        """

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

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

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

        filenodes = [FileNode(f, changeset=self) for f in self._file_paths

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

        dirs = path == '' and '' or [d for d in self._dir_paths

            if d and posixpath.dirname(d) == path]

        dirnodes = [DirNode(d, changeset=self) for d in dirs

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

        als = self.repository.alias

        for k, vals in self._extract_submodules().items():

            #vals = url,rev,type

            loc = vals[0]

            cs = vals[1]

            dirnodes.append(SubModuleNode(k, url=loc, changeset=cs,

                                          alias=als))

        nodes = dirnodes + filenodes

        for node in nodes:

            self.nodes[node.path] = node

        nodes.sort()

        return nodes

    def get_node(self, path):

        """

        Returns ``Node`` object from the given ``path``. If there is no node at

        the given ``path``, ``ChangesetError`` would be raised.

        """

        if path not in self.nodes:

            if path in self._file_paths:

                node = FileNode(path, changeset=self)

            elif path in self._dir_paths or path in self._dir_paths:

                if path == '':

                    node = RootNode(changeset=self)

                else:

                    node = DirNode(path, changeset=self)

            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

        """

        return self._ctx.files()

    @property