def get_mimetype(self):

        """

        Mimetype is calculated based on the file's content. If ``_mimetype``

        attribute is available, it will be returned (backends which store

        mimetypes or can easily recognize them, should set this private

        attribute to indicate that type should *NOT* be calculated).

        """

        if hasattr(self, '_mimetype'):

            if (isinstance(self._mimetype, (tuple, list,)) and

                len(self._mimetype) == 2):

                return self._mimetype

            else:

                raise NodeError('given _mimetype attribute must be an 2 '

                               'element list or tuple')

        mtype, encoding = mimetypes.guess_type(self.name)

        if mtype is None:

            if self.is_binary:

                mtype = 'application/octet-stream'

                encoding = None

            else:

                mtype = 'text/plain'

                encoding = None

        return mtype, encoding

    @LazyProperty

    def mimetype(self):

        """

        Wrapper around full mimetype info. It returns only type of fetched

        mimetype without the encoding part. use get_mimetype function to fetch

        full set of (type,encoding)

        """

        return self.get_mimetype()[0]

    @LazyProperty

    def mimetype_main(self):

        return ['', '']

        return self.mimetype.split('/')[0]

    @LazyProperty

    def lexer(self):

        """

        Returns pygment's lexer class. Would try to guess lexer taking file's

        content, name and mimetype.

        """

        try:

            lexer = lexers.guess_lexer_for_filename(self.name, self.content)

        except lexers.ClassNotFound:

            lexer = lexers.TextLexer()

        # returns first alias

        return lexer

    @LazyProperty

    def lexer_alias(self):

        """

        Returns first alias of the lexer guessed for this file.

        """

        return self.lexer.aliases[0]

    @LazyProperty

    def history(self):

        """

        Returns a list of changeset for this file in which the file was changed

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_history(self.path)

    @LazyProperty

    def annotate(self):

        """

        Returns a list of three element tuples with lineno,changeset and line

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_annotate(self.path)

    @LazyProperty

    def state(self):

        if not self.changeset:

            raise NodeError("Cannot check state of the node if it's not "

                "linked with changeset")

        elif self.path in (node.path for node in self.changeset.added):

            return NodeState.ADDED

        elif self.path in (node.path for node in self.changeset.changed):

            return NodeState.CHANGED

        else:

            return NodeState.NOT_CHANGED

    @property

    def is_binary(self):

        """

        Returns True if file has binary content.

        """

        _bin = '\0' in self._get_content()

        return _bin

    @LazyProperty

    def extension(self):

        """Returns filenode extension"""

        return self.name.split('.')[-1]

    def is_executable(self):

        """

        Returns ``True`` if file has executable flag turned on.

        """

        return bool(self.mode & stat.S_IXUSR)

    def __repr__(self):

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

                                 getattr(self.changeset, 'short_id', ''))

class RemovedFileNode(FileNode):

    """

    Dummy FileNode class - trying to access any public attribute except path,

    name, kind or state (or methods/attributes checking those two) would raise

    RemovedFileNodeError.

    """

    ALLOWED_ATTRIBUTES = [

        'name', 'path', 'state', 'is_root', 'is_file', 'is_dir', 'kind',

        'added', 'changed', 'not_changed', 'removed'

    ]

    def __init__(self, path):

        """

        :param path: relative path to the node

        """

        super(RemovedFileNode, self).__init__(path=path)

    def __getattribute__(self, attr):

        if attr.startswith('_') or attr in RemovedFileNode.ALLOWED_ATTRIBUTES:

            return super(RemovedFileNode, self).__getattribute__(attr)

        raise RemovedFileNodeError("Cannot access attribute %s on "

            "RemovedFileNode" % attr)

    @LazyProperty

    def state(self):

        return NodeState.REMOVED

class DirNode(Node):

    """

    DirNode stores list of files and directories within this node.

    Nodes may be used standalone but within repository context they

    lazily fetch data within same repositorty's changeset.

    """

    def __init__(self, path, nodes=(), changeset=None):

        """

        Only one of ``nodes`` and ``changeset`` may be given. Passing both

        would raise ``NodeError`` exception.

        :param path: relative path to the node

        :param nodes: content may be passed to constructor

        :param changeset: if given, will use it to lazily fetch content

        :param size: always 0 for ``DirNode``

        """

        if nodes and changeset:

            raise NodeError("Cannot use both nodes and changeset")

        super(DirNode, self).__init__(path, NodeKind.DIR)

        self.changeset = changeset

        self._nodes = nodes

    @LazyProperty

    def content(self):

        raise NodeError("%s represents a dir and has no ``content`` attribute"

            % self)

    @LazyProperty

    def nodes(self):

        if self.changeset:

            nodes = self.changeset.get_nodes(self.path)

        else:

            nodes = self._nodes

        self._nodes_dict = dict((node.path, node) for node in nodes)

        return sorted(nodes)

    @LazyProperty

    def files(self):

        return sorted((node for node in self.nodes if node.is_file()))

    @LazyProperty

    def dirs(self):

        return sorted((node for node in self.nodes if node.is_dir()))

    def __iter__(self):

        for node in self.nodes:

            yield node