may be ``raw_id`` or i.e. for mercurial's tip just ``tip``

        ``raw_id``

            raw changeset representation (i.e. full 40 length sha for git

            backend)

        ``short_id``

            shortened (if apply) version of ``raw_id``; it would be simple

            shortcut for ``raw_id[:12]`` for git/mercurial backends or same

            as ``raw_id`` for subversion

        ``revision``

            revision number as integer

        ``files``

            list of ``FileNode`` (``Node`` with NodeKind.FILE) objects

        ``dirs``

            list of ``DirNode`` (``Node`` with NodeKind.DIR) objects

        ``nodes``

            combined list of ``Node`` objects

        ``author``

            author of the changeset, as unicode

        ``message``

            message of the changeset, as unicode

        ``parents``

            list of parent changesets

        ``last``

            ``True`` if this is last changeset in repository, ``False``

            otherwise; trying to access this attribute while there is no

            changesets would raise ``EmptyRepositoryError``

    """

    def __str__(self):

        return '<%s at %s:%s>' % (self.__class__.__name__, self.revision,

            self.short_id)

    def __repr__(self):

        return self.__str__()

    def __unicode__(self):

        return u'%s:%s' % (self.revision, self.short_id)

    def __eq__(self, other):

        return self.raw_id == other.raw_id

    def __json__(self, with_file_list=False):

        if with_file_list:

            return dict(

                short_id=self.short_id,

                raw_id=self.raw_id,

                revision=self.revision,

                message=self.message,

                date=self.date,

                author=self.author,

                added=[safe_unicode(el.path) for el in self.added],

                changed=[safe_unicode(el.path) for el in self.changed],

                removed=[safe_unicode(el.path) for el in self.removed],

            )

        else:

            return dict(

                short_id=self.short_id,

                raw_id=self.raw_id,

                revision=self.revision,

                message=self.message,

                date=self.date,

                author=self.author,

            )

    @LazyProperty

    def last(self):

        if self.repository is None:

            raise ChangesetError("Cannot check if it's most recent revision")

        return self.raw_id == self.repository.revisions[-1]

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        raise NotImplementedError

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        raise NotImplementedError

    @LazyProperty

    def id(self):

        """

    so it cannot end with slash, too. Otherwise, path could lead to mistakes.

    """

    def __init__(self, path, kind):

        if path.startswith('/'):

            raise NodeError("Cannot initialize Node objects with slash at "

                            "the beginning as only relative paths are supported")

        self.path = safe_str(path.rstrip('/'))  # we store paths as str

        if path == '' and kind != NodeKind.DIR:

            raise NodeError("Only DirNode and its subclasses may be "

                            "initialized with empty path")

        self.kind = kind

        #self.dirs, self.files = [], []

        if self.is_root() and not self.is_dir():

            raise NodeError("Root node cannot be FILE kind")

    @LazyProperty

    def parent(self):

        parent_path = self.get_parent_path()

        if parent_path:

            if self.changeset:

                return self.changeset.get_node(parent_path)

            return DirNode(parent_path)

        return None

    @LazyProperty

    def name(self):

        """

        Returns name of the node so if its path

        then only last part is returned.

        """

        return safe_unicode(self.path.rstrip('/').split('/')[-1])

    def _get_kind(self):

        return self._kind

    def _set_kind(self, kind):

        if hasattr(self, '_kind'):

            raise NodeError("Cannot change node's kind")

        else:

            self._kind = kind

            # Post setter check (path's trailing slash)

            if self.path.endswith('/'):

                raise NodeError("Node's path cannot end with slash")

    kind = property(_get_kind, _set_kind)

    def __eq__(self, other):

        if self._kind != other._kind:

            return False

        if self.path != other.path:

            return False

        if self.is_file():

            return self.content == other.content

        else:

            # For DirNode's check without entering each dir

            self_nodes_paths = list(sorted(n.path for n in self.nodes))

            other_nodes_paths = list(sorted(n.path for n in self.nodes))

            return self_nodes_paths == other_nodes_paths

    def __lt__(self, other):

        if self._kind < other._kind:

            return True

        if self._kind > other._kind:

            return False

        if self.path < other.path:

            return True

        if self.path > other.path:

            return False

        if self.is_file():

            return self.content < other.content

        else:

            # For DirNode's check without entering each dir

            self_nodes_paths = list(sorted(n.path for n in self.nodes))

            other_nodes_paths = list(sorted(n.path for n in self.nodes))

            return self_nodes_paths < other_nodes_paths

    def __repr__(self):

        return '<%s %r>' % (self.__class__.__name__, self.path)

    def __str__(self):

        return self.__repr__()

    def __unicode__(self):

        return self.name

    def get_parent_path(self):

        """

        Returns node's parent path or empty string if node is root.

        """

        if self.is_root():

            return ''

        return posixpath.dirname(self.path.rstrip('/')) + '/'

    def is_file(self):

        """