mimetypes.py 20.3 KB
Newer Older
1 2
"""Guess the MIME type of a file.

3
This module defines two useful functions:
4

5
guess_type(url, strict=True) -- guess the MIME type and encoding of a URL.
6

7
guess_extension(type, strict=True) -- guess the extension for a given MIME type.
8

9 10 11 12 13 14
It also contains the following, for tuning the behavior:

Data:

knownfiles -- list of files to parse
inited -- flag set when init() has been called
15
suffix_map -- dictionary mapping suffixes to suffixes
16 17 18 19 20
encodings_map -- dictionary mapping suffixes to encodings
types_map -- dictionary mapping suffixes to types

Functions:

21 22
init([files]) -- parse a list of files, default knownfiles (on Windows, the
  default values are taken from the registry)
23 24 25
read_mime_types(file) -- parse one file, return a dictionary or None
"""

26
import os
27
import sys
28
import posixpath
29
import urllib.parse
30 31
try:
    import winreg as _winreg
32
except ImportError:
33
    _winreg = None
34

35
__all__ = [
36 37 38 39
    "knownfiles", "inited", "MimeTypes",
    "guess_type", "guess_all_extensions", "guess_extension",
    "add_type", "init", "read_mime_types",
    "suffix_map", "encodings_map", "types_map", "common_types"
40
]
41

42
knownfiles = [
43
    "/etc/mime.types",
44 45 46 47
    "/etc/httpd/mime.types",                    # Mac OS X
    "/etc/httpd/conf/mime.types",               # Apache
    "/etc/apache/mime.types",                   # Apache 1
    "/etc/apache2/mime.types",                  # Apache 2
48 49
    "/usr/local/etc/httpd/conf/mime.types",
    "/usr/local/lib/netscape/mime.types",
50 51
    "/usr/local/etc/httpd/conf/mime.types",     # Apache 1.2
    "/usr/local/etc/mime.types",                # Apache 1.3
52 53
    ]

54
inited = False
55
_db = None
56

57 58 59 60 61 62 63 64 65

class MimeTypes:
    """MIME-types datastore.

    This datastore can handle information from mime.types-style files
    and supports basic determination of MIME type from a filename or
    URL, and can guess a reasonable extension given a MIME type.
    """

66
    def __init__(self, filenames=(), strict=True):
67 68 69 70
        if not inited:
            init()
        self.encodings_map = encodings_map.copy()
        self.suffix_map = suffix_map.copy()
71 72 73 74 75 76
        self.types_map = ({}, {}) # dict for (non-strict, strict)
        self.types_map_inv = ({}, {})
        for (ext, type) in types_map.items():
            self.add_type(type, ext, True)
        for (ext, type) in common_types.items():
            self.add_type(type, ext, False)
77
        for name in filenames:
78
            self.read(name, strict)
79

80
    def add_type(self, type, ext, strict=True):
81
        """Add a mapping between a type and an extension.
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

        When the extension is already known, the new
        type will replace the old one. When the type
        is already known the extension will be added
        to the list of known extensions.

        If strict is true, information will be added to
        list of standard types, else to the list of non-standard
        types.
        """
        self.types_map[strict][ext] = type
        exts = self.types_map_inv[strict].setdefault(type, [])
        if ext not in exts:
            exts.append(ext)

    def guess_type(self, url, strict=True):
98 99 100 101 102 103 104 105 106 107 108 109 110 111
        """Guess the type of a file based on its URL.

        Return value is a tuple (type, encoding) where type is None if
        the type can't be guessed (no or unknown suffix) or a string
        of the form type/subtype, usable for a MIME Content-type
        header; and encoding is None for no encoding or the name of
        the program used to encode (e.g. compress or gzip).  The
        mappings are table driven.  Encoding suffixes are case
        sensitive; type suffixes are first tried case sensitive, then
        case insensitive.

        The suffixes .tgz, .taz and .tz (case sensitive!) are all
        mapped to '.tar.gz'.  (This is table-driven too, using the
        dictionary suffix_map.)
112

113
        Optional `strict' argument when False adds a bunch of commonly found,
114
        but non-standard types.
115
        """
116
        scheme, url = urllib.parse._splittype(url)
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
        if scheme == 'data':
            # syntax of data URLs:
            # dataurl   := "data:" [ mediatype ] [ ";base64" ] "," data
            # mediatype := [ type "/" subtype ] *( ";" parameter )
            # data      := *urlchar
            # parameter := attribute "=" value
            # type/subtype defaults to "text/plain"
            comma = url.find(',')
            if comma < 0:
                # bad data URL
                return None, None
            semi = url.find(';', 0, comma)
            if semi >= 0:
                type = url[:semi]
            else:
                type = url[:comma]
            if '=' in type or '/' not in type:
                type = 'text/plain'
            return type, None           # never compressed, so encoding is None
        base, ext = posixpath.splitext(url)
137
        while ext in self.suffix_map:
138
            base, ext = posixpath.splitext(base + self.suffix_map[ext])
139
        if ext in self.encodings_map:
140 141 142 143
            encoding = self.encodings_map[ext]
            base, ext = posixpath.splitext(base)
        else:
            encoding = None
144
        types_map = self.types_map[True]
145
        if ext in types_map:
146
            return types_map[ext], encoding
147
        elif ext.lower() in types_map:
148
            return types_map[ext.lower()], encoding
149 150
        elif strict:
            return None, encoding
151 152 153 154 155
        types_map = self.types_map[False]
        if ext in types_map:
            return types_map[ext], encoding
        elif ext.lower() in types_map:
            return types_map[ext.lower()], encoding
156 157 158
        else:
            return None, encoding

159 160 161 162 163
    def guess_all_extensions(self, type, strict=True):
        """Guess the extensions for a file based on its MIME type.

        Return value is a list of strings giving the possible filename
        extensions, including the leading dot ('.').  The extension is not
164 165
        guaranteed to have been associated with any particular data stream,
        but would be mapped to the MIME type `type' by guess_type().
166 167 168 169 170 171 172 173 174 175

        Optional `strict' argument when false adds a bunch of commonly found,
        but non-standard types.
        """
        type = type.lower()
        extensions = self.types_map_inv[True].get(type, [])
        if not strict:
            for ext in self.types_map_inv[False].get(type, []):
                if ext not in extensions:
                    extensions.append(ext)
176
        return extensions
177 178

    def guess_extension(self, type, strict=True):
179 180 181 182 183 184 185 186
        """Guess the extension for a file based on its MIME type.

        Return value is a string giving a filename extension,
        including the leading dot ('.').  The extension is not
        guaranteed to have been associated with any particular data
        stream, but would be mapped to the MIME type `type' by
        guess_type().  If no extension can be guessed for `type', None
        is returned.
187 188 189

        Optional `strict' argument when false adds a bunch of commonly found,
        but non-standard types.
190
        """
191
        extensions = self.guess_all_extensions(type, strict)
192 193 194
        if not extensions:
            return None
        return extensions[0]
195 196 197 198

    def read(self, filename, strict=True):
        """
        Read a single mime.types-format file, specified by pathname.
199

200 201 202 203
        If strict is true, information will be added to
        list of standard types, else to the list of non-standard
        types.
        """
204
        with open(filename, encoding='utf-8') as fp:
205
            self.readfp(fp, strict)
206

207 208 209 210 211 212 213 214
    def readfp(self, fp, strict=True):
        """
        Read a single mime.types-format file.

        If strict is true, information will be added to
        list of standard types, else to the list of non-standard
        types.
        """
215
        while 1:
216
            line = fp.readline()
217 218 219 220 221 222 223 224 225 226 227
            if not line:
                break
            words = line.split()
            for i in range(len(words)):
                if words[i][0] == '#':
                    del words[i:]
                    break
            if not words:
                continue
            type, suffixes = words[0], words[1:]
            for suff in suffixes:
228
                self.add_type(type, '.' + suff, strict)
229

230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
    def read_windows_registry(self, strict=True):
        """
        Load the MIME types database from Windows registry.

        If strict is true, information will be added to
        list of standard types, else to the list of non-standard
        types.
        """

        # Windows only
        if not _winreg:
            return

        def enum_types(mimedb):
            i = 0
            while True:
                try:
                    ctype = _winreg.EnumKey(mimedb, i)
248
                except OSError:
249 250
                    break
                else:
251 252
                    if '\0' not in ctype:
                        yield ctype
253 254
                i += 1

255 256
        with _winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT, '') as hkcr:
            for subkeyname in enum_types(hkcr):
257
                try:
258 259 260 261
                    with _winreg.OpenKey(hkcr, subkeyname) as subkey:
                        # Only check file extensions
                        if not subkeyname.startswith("."):
                            continue
262
                        # raises OSError if no 'Content Type' value
263 264 265 266 267
                        mimetype, datatype = _winreg.QueryValueEx(
                            subkey, 'Content Type')
                        if datatype != _winreg.REG_SZ:
                            continue
                        self.add_type(mimetype, subkeyname, strict)
268
                except OSError:
269
                    continue
270

271
def guess_type(url, strict=True):
272 273 274 275 276 277 278 279 280 281 282 283
    """Guess the type of a file based on its URL.

    Return value is a tuple (type, encoding) where type is None if the
    type can't be guessed (no or unknown suffix) or a string of the
    form type/subtype, usable for a MIME Content-type header; and
    encoding is None for no encoding or the name of the program used
    to encode (e.g. compress or gzip).  The mappings are table
    driven.  Encoding suffixes are case sensitive; type suffixes are
    first tried case sensitive, then case insensitive.

    The suffixes .tgz, .taz and .tz (case sensitive!) are all mapped
    to ".tar.gz".  (This is table-driven too, using the dictionary
284
    suffix_map).
285 286 287

    Optional `strict' argument when false adds a bunch of commonly found, but
    non-standard types.
288
    """
289
    if _db is None:
Benjamin Peterson's avatar
Benjamin Peterson committed
290
        init()
291
    return _db.guess_type(url, strict)
292

293

294 295 296 297 298 299 300 301 302 303 304 305 306
def guess_all_extensions(type, strict=True):
    """Guess the extensions for a file based on its MIME type.

    Return value is a list of strings giving the possible filename
    extensions, including the leading dot ('.').  The extension is not
    guaranteed to have been associated with any particular data
    stream, but would be mapped to the MIME type `type' by
    guess_type().  If no extension can be guessed for `type', None
    is returned.

    Optional `strict' argument when false adds a bunch of commonly found,
    but non-standard types.
    """
307
    if _db is None:
Benjamin Peterson's avatar
Benjamin Peterson committed
308
        init()
309
    return _db.guess_all_extensions(type, strict)
310 311

def guess_extension(type, strict=True):
312 313 314 315
    """Guess the extension for a file based on its MIME type.

    Return value is a string giving a filename extension, including the
    leading dot ('.').  The extension is not guaranteed to have been
316 317 318
    associated with any particular data stream, but would be mapped to the
    MIME type `type' by guess_type().  If no extension can be guessed for
    `type', None is returned.
319 320 321

    Optional `strict' argument when false adds a bunch of commonly found,
    but non-standard types.
322
    """
323
    if _db is None:
Benjamin Peterson's avatar
Benjamin Peterson committed
324
        init()
325
    return _db.guess_extension(type, strict)
326

327
def add_type(type, ext, strict=True):
328
    """Add a mapping between a type and an extension.
329 330 331 332 333 334 335 336 337 338

    When the extension is already known, the new
    type will replace the old one. When the type
    is already known the extension will be added
    to the list of known extensions.

    If strict is true, information will be added to
    list of standard types, else to the list of non-standard
    types.
    """
339
    if _db is None:
Benjamin Peterson's avatar
Benjamin Peterson committed
340
        init()
341
    return _db.add_type(type, ext, strict)
342

343

344
def init(files=None):
345
    global suffix_map, types_map, encodings_map, common_types
346 347
    global inited, _db
    inited = True    # so that MimeTypes.__init__() doesn't call us again
348 349
    db = MimeTypes()
    if files is None:
350 351
        if _winreg:
            db.read_windows_registry()
352 353 354
        files = knownfiles
    for file in files:
        if os.path.isfile(file):
355
            db.read(file)
356
    encodings_map = db.encodings_map
357
    suffix_map = db.suffix_map
358 359
    types_map = db.types_map[True]
    common_types = db.types_map[False]
360 361
    # Make the DB a global variable now that it is fully initialized
    _db = db
362

363 364 365

def read_mime_types(file):
    try:
366
        f = open(file)
367
    except OSError:
368
        return None
369 370 371 372
    with f:
        db = MimeTypes()
        db.readfp(f, True)
        return db.types_map[True]
373

374

375 376 377 378 379 380 381
def _default_mime_types():
    global suffix_map
    global encodings_map
    global types_map
    global common_types

    suffix_map = {
382
        '.svgz': '.svg.gz',
383 384 385
        '.tgz': '.tar.gz',
        '.taz': '.tar.gz',
        '.tz': '.tar.gz',
386
        '.tbz2': '.tar.bz2',
387
        '.txz': '.tar.xz',
388 389 390 391 392
        }

    encodings_map = {
        '.gz': 'gzip',
        '.Z': 'compress',
393
        '.bz2': 'bzip2',
394
        '.xz': 'xz',
395 396 397
        }

    # Before adding new types, make sure they are either registered with IANA,
398
    # at http://www.iana.org/assignments/media-types
399 400 401 402 403 404 405 406 407 408 409 410 411 412
    # or extensions, i.e. using the x- prefix

    # If you add to these, please keep them sorted!
    types_map = {
        '.a'      : 'application/octet-stream',
        '.ai'     : 'application/postscript',
        '.aif'    : 'audio/x-aiff',
        '.aifc'   : 'audio/x-aiff',
        '.aiff'   : 'audio/x-aiff',
        '.au'     : 'audio/basic',
        '.avi'    : 'video/x-msvideo',
        '.bat'    : 'text/plain',
        '.bcpio'  : 'application/x-bcpio',
        '.bin'    : 'application/octet-stream',
413
        '.bmp'    : 'image/bmp',
414 415 416 417 418
        '.c'      : 'text/plain',
        '.cdf'    : 'application/x-netcdf',
        '.cpio'   : 'application/x-cpio',
        '.csh'    : 'application/x-csh',
        '.css'    : 'text/css',
419
        '.csv'    : 'text/csv',
420 421 422 423 424 425 426 427 428 429 430 431 432 433
        '.dll'    : 'application/octet-stream',
        '.doc'    : 'application/msword',
        '.dot'    : 'application/msword',
        '.dvi'    : 'application/x-dvi',
        '.eml'    : 'message/rfc822',
        '.eps'    : 'application/postscript',
        '.etx'    : 'text/x-setext',
        '.exe'    : 'application/octet-stream',
        '.gif'    : 'image/gif',
        '.gtar'   : 'application/x-gtar',
        '.h'      : 'text/plain',
        '.hdf'    : 'application/x-hdf',
        '.htm'    : 'text/html',
        '.html'   : 'text/html',
434
        '.ico'    : 'image/vnd.microsoft.icon',
435 436 437 438
        '.ief'    : 'image/ief',
        '.jpe'    : 'image/jpeg',
        '.jpeg'   : 'image/jpeg',
        '.jpg'    : 'image/jpeg',
439
        '.js'     : 'application/javascript',
440
        '.json'   : 'application/json',
441 442 443
        '.ksh'    : 'text/plain',
        '.latex'  : 'application/x-latex',
        '.m1v'    : 'video/mpeg',
444 445
        '.m3u'    : 'application/vnd.apple.mpegurl',
        '.m3u8'   : 'application/vnd.apple.mpegurl',
446 447 448 449 450 451 452 453 454
        '.man'    : 'application/x-troff-man',
        '.me'     : 'application/x-troff-me',
        '.mht'    : 'message/rfc822',
        '.mhtml'  : 'message/rfc822',
        '.mif'    : 'application/x-mif',
        '.mov'    : 'video/quicktime',
        '.movie'  : 'video/x-sgi-movie',
        '.mp2'    : 'audio/mpeg',
        '.mp3'    : 'audio/mpeg',
455
        '.mp4'    : 'video/mp4',
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
        '.mpa'    : 'video/mpeg',
        '.mpe'    : 'video/mpeg',
        '.mpeg'   : 'video/mpeg',
        '.mpg'    : 'video/mpeg',
        '.ms'     : 'application/x-troff-ms',
        '.nc'     : 'application/x-netcdf',
        '.nws'    : 'message/rfc822',
        '.o'      : 'application/octet-stream',
        '.obj'    : 'application/octet-stream',
        '.oda'    : 'application/oda',
        '.p12'    : 'application/x-pkcs12',
        '.p7c'    : 'application/pkcs7-mime',
        '.pbm'    : 'image/x-portable-bitmap',
        '.pdf'    : 'application/pdf',
        '.pfx'    : 'application/x-pkcs12',
        '.pgm'    : 'image/x-portable-graymap',
        '.pl'     : 'text/plain',
        '.png'    : 'image/png',
        '.pnm'    : 'image/x-portable-anymap',
        '.pot'    : 'application/vnd.ms-powerpoint',
        '.ppa'    : 'application/vnd.ms-powerpoint',
        '.ppm'    : 'image/x-portable-pixmap',
        '.pps'    : 'application/vnd.ms-powerpoint',
        '.ppt'    : 'application/vnd.ms-powerpoint',
        '.ps'     : 'application/postscript',
        '.pwz'    : 'application/vnd.ms-powerpoint',
        '.py'     : 'text/x-python',
        '.pyc'    : 'application/x-python-code',
        '.pyo'    : 'application/x-python-code',
        '.qt'     : 'video/quicktime',
        '.ra'     : 'audio/x-pn-realaudio',
        '.ram'    : 'application/x-pn-realaudio',
        '.ras'    : 'image/x-cmu-raster',
        '.rdf'    : 'application/xml',
        '.rgb'    : 'image/x-rgb',
        '.roff'   : 'application/x-troff',
        '.rtx'    : 'text/richtext',
        '.sgm'    : 'text/x-sgml',
        '.sgml'   : 'text/x-sgml',
        '.sh'     : 'application/x-sh',
        '.shar'   : 'application/x-shar',
        '.snd'    : 'audio/basic',
        '.so'     : 'application/octet-stream',
        '.src'    : 'application/x-wais-source',
        '.sv4cpio': 'application/x-sv4cpio',
        '.sv4crc' : 'application/x-sv4crc',
Éric Araujo's avatar
Éric Araujo committed
502
        '.svg'    : 'image/svg+xml',
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
        '.swf'    : 'application/x-shockwave-flash',
        '.t'      : 'application/x-troff',
        '.tar'    : 'application/x-tar',
        '.tcl'    : 'application/x-tcl',
        '.tex'    : 'application/x-tex',
        '.texi'   : 'application/x-texinfo',
        '.texinfo': 'application/x-texinfo',
        '.tif'    : 'image/tiff',
        '.tiff'   : 'image/tiff',
        '.tr'     : 'application/x-troff',
        '.tsv'    : 'text/tab-separated-values',
        '.txt'    : 'text/plain',
        '.ustar'  : 'application/x-ustar',
        '.vcf'    : 'text/x-vcard',
        '.wav'    : 'audio/x-wav',
518
        '.webm'   : 'video/webm',
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
        '.wiz'    : 'application/msword',
        '.wsdl'   : 'application/xml',
        '.xbm'    : 'image/x-xbitmap',
        '.xlb'    : 'application/vnd.ms-excel',
        '.xls'    : 'application/vnd.ms-excel',
        '.xml'    : 'text/xml',
        '.xpdl'   : 'application/xml',
        '.xpm'    : 'image/x-xpixmap',
        '.xsl'    : 'application/xml',
        '.xwd'    : 'image/x-xwindowdump',
        '.zip'    : 'application/zip',
        }

    # These are non-standard types, commonly found in the wild.  They will
    # only match if strict=0 flag is given to the API methods.

    # Please sort these too
    common_types = {
        '.jpg' : 'image/jpg',
        '.mid' : 'audio/midi',
        '.midi': 'audio/midi',
        '.pct' : 'image/pict',
        '.pic' : 'image/pict',
        '.pict': 'image/pict',
        '.rtf' : 'application/rtf',
        '.xul' : 'text/xul'
        }


_default_mime_types()
549 550


551
if __name__ == '__main__':
552 553
    import getopt

554 555 556 557 558 559 560 561 562 563 564 565 566
    USAGE = """\
Usage: mimetypes.py [options] type

Options:
    --help / -h       -- print this message and exit
    --lenient / -l    -- additionally search of some common, but non-standard
                         types.
    --extension / -e  -- guess extension instead of type

More than one type argument may be given.
"""

    def usage(code, msg=''):
567 568
        print(USAGE)
        if msg: print(msg)
569 570
        sys.exit(code)

571 572 573
    try:
        opts, args = getopt.getopt(sys.argv[1:], 'hle',
                                   ['help', 'lenient', 'extension'])
574
    except getopt.error as msg:
575 576 577 578 579 580 581 582 583 584 585 586 587 588
        usage(1, msg)

    strict = 1
    extension = 0
    for opt, arg in opts:
        if opt in ('-h', '--help'):
            usage(0)
        elif opt in ('-l', '--lenient'):
            strict = 0
        elif opt in ('-e', '--extension'):
            extension = 1
    for gtype in args:
        if extension:
            guess = guess_extension(gtype, strict)
589 590
            if not guess: print("I don't know anything about type", gtype)
            else: print(guess)
591 592
        else:
            guess, encoding = guess_type(gtype, strict)
593 594
            if not guess: print("I don't know anything about type", gtype)
            else: print('type:', guess, 'encoding:', encoding)