--- /dev/null
+"""
+This module is based on a rox module (LGPL):
+
+http://cvs.sourceforge.net/viewcvs.py/rox/ROX-Lib2/python/rox/mime.py?rev=1.21&view=log
+
+This module provides access to the shared MIME database.
+
+types is a dictionary of all known MIME types, indexed by the type name, e.g.
+types['application/x-python']
+
+Applications can install information about MIME types by storing an
+XML file as <MIME>/packages/<application>.xml and running the
+update-mime-database command, which is provided by the freedesktop.org
+shared mime database package.
+
+See http://www.freedesktop.org/standards/shared-mime-info-spec/ for
+information about the format of these files.
+
+(based on version 0.13)
+"""
+
+import os
+import stat
+import fnmatch
+
+import xdg.BaseDirectory
+import xdg.Locale
+
+from xml.dom import Node, minidom, XML_NAMESPACE
+
+FREE_NS = 'http://www.freedesktop.org/standards/shared-mime-info'
+
+types = {} # Maps MIME names to type objects
+
+exts = None # Maps extensions to types
+globs = None # List of (glob, type) pairs
+literals = None # Maps liternal names to types
+magic = None
+
+def _get_node_data(node):
+ """Get text of XML node"""
+ return ''.join([n.nodeValue for n in node.childNodes]).strip()
+
+def lookup(media, subtype = None):
+ "Get the MIMEtype object for this type, creating a new one if needed."
+ if subtype is None and '/' in media:
+ media, subtype = media.split('/', 1)
+ if (media, subtype) not in types:
+ types[(media, subtype)] = MIMEtype(media, subtype)
+ return types[(media, subtype)]
+
+class MIMEtype:
+ """Type holding data about a MIME type"""
+ def __init__(self, media, subtype):
+ "Don't use this constructor directly; use mime.lookup() instead."
+ assert media and '/' not in media
+ assert subtype and '/' not in subtype
+ assert (media, subtype) not in types
+
+ self.media = media
+ self.subtype = subtype
+ self._comment = None
+
+ def _load(self):
+ "Loads comment for current language. Use get_comment() instead."
+ resource = os.path.join('mime', self.media, self.subtype + '.xml')
+ for path in xdg.BaseDirectory.load_data_paths(resource):
+ doc = minidom.parse(path)
+ if doc is None:
+ continue
+ for comment in doc.documentElement.getElementsByTagNameNS(FREE_NS, 'comment'):
+ lang = comment.getAttributeNS(XML_NAMESPACE, 'lang') or 'en'
+ goodness = 1 + (lang in xdg.Locale.langs)
+ if goodness > self._comment[0]:
+ self._comment = (goodness, _get_node_data(comment))
+ if goodness == 2: return
+
+ # FIXME: add get_icon method
+ def get_comment(self):
+ """Returns comment for current language, loading it if needed."""
+ # Should we ever reload?
+ if self._comment is None:
+ self._comment = (0, str(self))
+ self._load()
+ return self._comment[1]
+
+ def __str__(self):
+ return self.media + '/' + self.subtype
+
+ def __repr__(self):
+ return '[%s: %s]' % (self, self._comment or '(comment not loaded)')
+
+class MagicRule:
+ def __init__(self, f):
+ self.next=None
+ self.prev=None
+
+ #print line
+ ind=''
+ while True:
+ c=f.read(1)
+ if c=='>':
+ break
+ ind+=c
+ if not ind:
+ self.nest=0
+ else:
+ self.nest=int(ind)
+
+ start=''
+ while True:
+ c=f.read(1)
+ if c=='=':
+ break
+ start+=c
+ self.start=int(start)
+
+ hb=f.read(1)
+ lb=f.read(1)
+ self.lenvalue=ord(lb)+(ord(hb)<<8)
+
+ self.value=f.read(self.lenvalue)
+
+ c=f.read(1)
+ if c=='&':
+ self.mask=f.read(self.lenvalue)
+ c=f.read(1)
+ else:
+ self.mask=None
+
+ if c=='~':
+ w=''
+ while c!='+' and c!='\n':
+ c=f.read(1)
+ if c=='+' or c=='\n':
+ break
+ w+=c
+
+ self.word=int(w)
+ else:
+ self.word=1
+
+ if c=='+':
+ r=''
+ while c!='\n':
+ c=f.read(1)
+ if c=='\n':
+ break
+ r+=c
+ #print r
+ self.range=int(r)
+ else:
+ self.range=1
+
+ if c!='\n':
+ raise 'Malformed MIME magic line'
+
+ def getLength(self):
+ return self.start+self.lenvalue+self.range
+
+ def appendRule(self, rule):
+ if self.nest<rule.nest:
+ self.next=rule
+ rule.prev=self
+
+ elif self.prev:
+ self.prev.appendRule(rule)
+
+ def match(self, buffer):
+ if self.match0(buffer):
+ if self.next:
+ return self.next.match(buffer)
+ return True
+
+ def match0(self, buffer):
+ l=len(buffer)
+ for o in range(self.range):
+ s=self.start+o
+ e=s+self.lenvalue
+ if l<e:
+ return False
+ if self.mask:
+ test=''
+ for i in range(self.lenvalue):
+ c=ord(buffer[s+i]) & ord(self.mask[i])
+ test+=chr(c)
+ else:
+ test=buffer[s:e]
+
+ if test==self.value:
+ return True
+
+ def __repr__(self):
+ return '<MagicRule %d>%d=[%d]%s&%s~%d+%d>' % (self.nest,
+ self.start,
+ self.lenvalue,
+ `self.value`,
+ `self.mask`,
+ self.word,
+ self.range)
+
+class MagicType:
+ def __init__(self, mtype):
+ self.mtype=mtype
+ self.top_rules=[]
+ self.last_rule=None
+
+ def getLine(self, f):
+ nrule=MagicRule(f)
+
+ if nrule.nest and self.last_rule:
+ self.last_rule.appendRule(nrule)
+ else:
+ self.top_rules.append(nrule)
+
+ self.last_rule=nrule
+
+ return nrule
+
+ def match(self, buffer):
+ for rule in self.top_rules:
+ if rule.match(buffer):
+ return self.mtype
+
+ def __repr__(self):
+ return '<MagicType %s>' % self.mtype
+
+class MagicDB:
+ def __init__(self):
+ self.types={} # Indexed by priority, each entry is a list of type rules
+ self.maxlen=0
+
+ def mergeFile(self, fname):
+ f=file(fname, 'r')
+ line=f.readline()
+ if line!='MIME-Magic\0\n':
+ raise 'Not a MIME magic file'
+
+ while True:
+ shead=f.readline()
+ #print shead
+ if not shead:
+ break
+ if shead[0]!='[' or shead[-2:]!=']\n':
+ raise 'Malformed section heading'
+ pri, tname=shead[1:-2].split(':')
+ #print shead[1:-2]
+ pri=int(pri)
+ mtype=lookup(tname)
+
+ try:
+ ents=self.types[pri]
+ except:
+ ents=[]
+ self.types[pri]=ents
+
+ magictype=MagicType(mtype)
+ #print tname
+
+ #rline=f.readline()
+ c=f.read(1)
+ f.seek(-1, 1)
+ while c and c!='[':
+ rule=magictype.getLine(f)
+ #print rule
+ if rule and rule.getLength()>self.maxlen:
+ self.maxlen=rule.getLength()
+
+ c=f.read(1)
+ f.seek(-1, 1)
+
+ ents.append(magictype)
+ #self.types[pri]=ents
+ if not c:
+ break
+
+ def match_data(self, data, max_pri=100, min_pri=0):
+ pris=self.types.keys()
+ pris.sort(lambda a, b: -cmp(a, b))
+ for pri in pris:
+ #print pri, max_pri, min_pri
+ if pri>max_pri:
+ continue
+ if pri<min_pri:
+ break
+ for type in self.types[pri]:
+ m=type.match(data)
+ if m:
+ return m
+
+
+ def match(self, path, max_pri=100, min_pri=0):
+ try:
+ buf=file(path, 'r').read(self.maxlen)
+ return self.match_data(buf, max_pri, min_pri)
+ except:
+ pass
+
+ return None
+
+ def __repr__(self):
+ return '<MagicDB %s>' % self.types
+
+
+# Some well-known types
+text = lookup('text', 'plain')
+inode_block = lookup('inode', 'blockdevice')
+inode_char = lookup('inode', 'chardevice')
+inode_dir = lookup('inode', 'directory')
+inode_fifo = lookup('inode', 'fifo')
+inode_socket = lookup('inode', 'socket')
+inode_symlink = lookup('inode', 'symlink')
+inode_door = lookup('inode', 'door')
+app_exe = lookup('application', 'executable')
+
+_cache_uptodate = False
+
+def _cache_database():
+ global exts, globs, literals, magic, _cache_uptodate
+
+ _cache_uptodate = True
+
+ exts = {} # Maps extensions to types
+ globs = [] # List of (glob, type) pairs
+ literals = {} # Maps liternal names to types
+ magic = MagicDB()
+
+ def _import_glob_file(path):
+ """Loads name matching information from a MIME directory."""
+ for line in file(path):
+ if line.startswith('#'): continue
+ line = line[:-1]
+
+ type_name, pattern = line.split(':', 1)
+ mtype = lookup(type_name)
+
+ if pattern.startswith('*.'):
+ rest = pattern[2:]
+ if not ('*' in rest or '[' in rest or '?' in rest):
+ exts[rest] = mtype
+ continue
+ if '*' in pattern or '[' in pattern or '?' in pattern:
+ globs.append((pattern, mtype))
+ else:
+ literals[pattern] = mtype
+
+ for path in xdg.BaseDirectory.load_data_paths(os.path.join('mime', 'globs')):
+ _import_glob_file(path)
+ for path in xdg.BaseDirectory.load_data_paths(os.path.join('mime', 'magic')):
+ magic.mergeFile(path)
+
+ # Sort globs by length
+ globs.sort(lambda a, b: cmp(len(b[0]), len(a[0])))
+
+def get_type_by_name(path):
+ """Returns type of file by its name, or None if not known"""
+ if not _cache_uptodate:
+ _cache_database()
+
+ leaf = os.path.basename(path)
+ if leaf in literals:
+ return literals[leaf]
+
+ lleaf = leaf.lower()
+ if lleaf in literals:
+ return literals[lleaf]
+
+ ext = leaf
+ while 1:
+ p = ext.find('.')
+ if p < 0: break
+ ext = ext[p + 1:]
+ if ext in exts:
+ return exts[ext]
+ ext = lleaf
+ while 1:
+ p = ext.find('.')
+ if p < 0: break
+ ext = ext[p+1:]
+ if ext in exts:
+ return exts[ext]
+ for (glob, mime_type) in globs:
+ if fnmatch.fnmatch(leaf, glob):
+ return mime_type
+ if fnmatch.fnmatch(lleaf, glob):
+ return mime_type
+ return None
+
+def get_type_by_contents(path, max_pri=100, min_pri=0):
+ """Returns type of file by its contents, or None if not known"""
+ if not _cache_uptodate:
+ _cache_database()
+
+ return magic.match(path, max_pri, min_pri)
+
+def get_type_by_data(data, max_pri=100, min_pri=0):
+ """Returns type of the data"""
+ if not _cache_uptodate:
+ _cache_database()
+
+ return magic.match_data(data, max_pri, min_pri)
+
+def get_type(path, follow=1, name_pri=100):
+ """Returns type of file indicated by path.
+ path - pathname to check (need not exist)
+ follow - when reading file, follow symbolic links
+ name_pri - Priority to do name matches. 100=override magic"""
+ if not _cache_uptodate:
+ _cache_database()
+
+ try:
+ if follow:
+ st = os.stat(path)
+ else:
+ st = os.lstat(path)
+ except:
+ t = get_type_by_name(path)
+ return t or text
+
+ if stat.S_ISREG(st.st_mode):
+ t = get_type_by_contents(path, min_pri=name_pri)
+ if not t: t = get_type_by_name(path)
+ if not t: t = get_type_by_contents(path, max_pri=name_pri)
+ if t is None:
+ if stat.S_IMODE(st.st_mode) & 0111:
+ return app_exe
+ else:
+ return text
+ return t
+ elif stat.S_ISDIR(st.st_mode): return inode_dir
+ elif stat.S_ISCHR(st.st_mode): return inode_char
+ elif stat.S_ISBLK(st.st_mode): return inode_block
+ elif stat.S_ISFIFO(st.st_mode): return inode_fifo
+ elif stat.S_ISLNK(st.st_mode): return inode_symlink
+ elif stat.S_ISSOCK(st.st_mode): return inode_socket
+ return inode_door
+
+def install_mime_info(application, package_file):
+ """Copy 'package_file' as ~/.local/share/mime/packages/<application>.xml.
+ If package_file is None, install <app_dir>/<application>.xml.
+ If already installed, does nothing. May overwrite an existing
+ file with the same name (if the contents are different)"""
+ application += '.xml'
+
+ new_data = file(package_file).read()
+
+ # See if the file is already installed
+ package_dir = os.path.join('mime', 'packages')
+ resource = os.path.join(package_dir, application)
+ for x in xdg.BaseDirectory.load_data_paths(resource):
+ try:
+ old_data = file(x).read()
+ except:
+ continue
+ if old_data == new_data:
+ return # Already installed
+
+ global _cache_uptodate
+ _cache_uptodate = False
+
+ # Not already installed; add a new copy
+ # Create the directory structure...
+ new_file = os.path.join(xdg.BaseDirectory.save_data_path(package_dir), application)
+
+ # Write the file...
+ file(new_file, 'w').write(new_data)
+
+ # Update the database...
+ command = 'update-mime-database'
+ if os.spawnlp(os.P_WAIT, command, command, xdg.BaseDirectory.save_data_path('mime')):
+ os.unlink(new_file)
+ raise Exception("The '%s' command returned an error code!\n" \
+ "Make sure you have the freedesktop.org shared MIME package:\n" \
+ "http://standards.freedesktop.org/shared-mime-info/") % command