root/sharedmimeinfo/trunk/sharedmimeinfo.py

import xml.dom.minidom as minidom
import os
from glob import glob

MIME_MEDIA = ('application', 'audio', 'image', 'inode', 'magic', 'message',
              'model', 'multipart', 'text', 'video')

class InvalidMimeType(Exception):
    """ Thrown if a MIME type is invalid. """

class InvalidMimeExtension(Exception):
    """ Thrown if a file extension has no matching MIME type. """

class MimeType:
    """ A representation of a MIME type. """
    def __init__(self, description, parent, type, aliases, globs):
        self.description, self.parent, self.type, self.aliases, self.globs = \
            description, parent, type, aliases, globs

    def __repr__(self):
        return "<%s.%s '%s'>" % (self.__module__, self.__class__.__name__, self.type)

class SharedMimeInfo:
    """ A Python interface to the shared-mime-info specification database
        (http://www.freedesktop.org/Standards/shared-mime-info-spec). """
    def __init__(self):
        self.paths = [x for x in (os.path.expanduser('~/.local/share/mime'), '/usr/local/share/mime', '/usr/share/mime') if os.path.isdir(x)]
        self.globs = {}
        self.extensions = {}
        self.aliases = {}
        for path in self.paths:
            # Load globs
            try:
                globfile = open(os.path.join(path, 'globs'), 'r')
                for line in globfile:
                    line = line.strip()
                    if line.startswith('#') or not line:
                        continue
                    type, glob = line.strip().split(':')
                    self.globs.setdefault(type, []).append(glob)
                    self.extensions[glob] = type
                globfile.close()
            except IOError:
                pass
            # Load aliases
            try:
                aliasfile = open(os.path.join(path, 'aliases'), 'r')
                for line in aliasfile:
                    alias, target = line.strip().split()
                    self.aliases[alias] = target
                aliasfile.close()
            except IOError:
                pass

    def _file_for_type(self, type):
        for path in self.paths:
            file = os.path.join(path, os.path.extsep.join([type, 'xml']))
            if os.path.isfile(file):
                return file
        raise InvalidMimeType(type)

    def lookup_type(self, type):
        """ Get a MimeType object for a MIME type. """
        if type in self.aliases:
            type = self.aliases[type]
        dom = minidom.parse(self._file_for_type(type))
        description = dom.getElementsByTagName('comment')[0].childNodes[0].data
        parent = dom.getElementsByTagName('sub-class-of')
        aliases = [x.attributes['type'].value for x in dom.getElementsByTagName('alias')]
        if parent:
            parent = parent[0].attributes['type'].value
        else:
            parent = None
        return MimeType(description, parent, type, aliases, list(self.globs[type]))

    def lookup_extension(self, extension):
        """ Get a MimeType object for a file extension. """
        try:
            return self.type(self.extensions['*.' + extension])
        except KeyError:
            raise InvalidMimeExtension(extension)

    def __iter__(self):
        """ Iterate over all available MIME type names. """
        global MIME_MEDIA
        for path in self.paths:
            for media in MIME_MEDIA:
                if os.path.isdir(os.path.join(path, media)):
                    for type in glob(os.path.join(path, media, '*.xml')):
                        yield '%s/%s' % (media, os.path.basename(os.path.splitext(type)[0]))

    def __getitem__(self, type):
        return self.lookup_type(type)