Python运行报错UnicodeDecodeError的解决方法

1. """Guess the MIME type of a file. 
2.   
3. This module defines two useful functions: 
4.   
5. guess_type(url, strict=1) -- guess the MIME type and encoding of a URL. 
6.   
7. guess_extension(type, strict=1) -- guess the extension for a given MIME type. 
8.   
9. It also contains the following, for tuning the behavior: 
10.   
11. Data: 
12.   
13. knownfiles -- list of files to parse 
14. inited -- flag set when init() has been called 
15. suffix_map -- dictionary mapping suffixes to suffixes 
16. encodings_map -- dictionary mapping suffixes to encodings 
17. types_map -- dictionary mapping suffixes to types 
18.   
19. Functions: 
20.   
21. init([files]) -- parse a list of files, default knownfiles (on Windows, the 
22.  default values are taken from the registry) 
23. read_mime_types(file) -- parse one file, return a dictionary or None 
24. """ 
25. from itertools import count 
26.   
27. import os 
28. import sys 
29. import posixpath 
30. import urllib 
31. try: 
32.  import _winreg 
33. except ImportError: 
34.  _winreg = None 
35.   
36. __all__ = [ 
37.  "guess_type","guess_extension","guess_all_extensions", 
38.  "add_type","read_mime_types","init" 
39. ] 
40.   
41. knownfiles = [ 
42.  "/etc/mime.types", 
43.  "/etc/httpd/mime.types",     # Mac OS X 
44.  "/etc/httpd/conf/mime.types",    # Apache 
45.  "/etc/apache/mime.types",     # Apache 1 
46.  "/etc/apache2/mime.types",     # Apache 2 
47.  "/usr/local/etc/httpd/conf/mime.types", 
48.  "/usr/local/lib/netscape/mime.types", 
49.  "/usr/local/etc/httpd/conf/mime.types",  # Apache 1.2 
50.  "/usr/local/etc/mime.types",    # Apache 1.3 
51.  ] 
52.   
53. inited = False 
54. _db = None 
55.   
56.   
57. class MimeTypes: 
58.  """MIME-types datastore. 
59.   
60.  This datastore can handle information from mime.types-style files 
61.  and supports basic determination of MIME type from a filename or 
62.  URL, and can guess a reasonable extension given a MIME type. 
63.  """ 
64.   
65.  def __init__(self, filenames=(), strict=True): 
66.   if not inited: 
67.    init() 
68.   self.encodings_map = encodings_map.copy() 
69.   self.suffix_map = suffix_map.copy() 
70.   self.types_map = ({}, {}) # dict for (non-strict, strict) 
71.   self.types_map_inv = ({}, {}) 
72.   for (ext, type) in types_map.items(): 
73.    self.add_type(type, ext, True) 
74.   for (ext, type) in common_types.items(): 
75.    self.add_type(type, ext, False) 
76.   for name in filenames: 
77.    self.read(name, strict) 
78.   
79.  def add_type(self, type, ext, strict=True): 
80.   """Add a mapping between a type and an extension. 
81.   
82.   When the extension is already known, the new 
83.   type will replace the old one. When the type 
84.   is already known the extension will be added 
85.   to the list of known extensions. 
86.   
87.   If strict is true, information will be added to 
88.   list of standard types, else to the list of non-standard 
89.   types. 
90.   """ 
91.   self.types_map[strict][ext] = type 
92.   exts = self.types_map_inv[strict].setdefault(type, []) 
93.   if ext not in exts: 
94.    exts.append(ext) 
95.   
96.  def guess_type(self, url, strict=True): 
97.   """Guess the type of a file based on its URL. 
98.   
99.   Return value is a tuple (type, encoding) where type is None if 
100.   the type can't be guessed (no or unknown suffix) or a string 
101.   of the form type/subtype, usable for a MIME Content-type 
102.   header; and encoding is None for no encoding or the name of 
103.   the program used to encode (e.g. compress or gzip). The 
104.   mappings are table driven. Encoding suffixes are case 
105.   sensitive; type suffixes are first tried case sensitive, then 
106.   case insensitive. 
107.   
108.   The suffixes .tgz, .taz and .tz (case sensitive!) are all 
109.   mapped to '.tar.gz'. (This is table-driven too, using the 
110.   dictionary suffix_map.) 
111.   
112.   Optional `strict' argument when False adds a bunch of commonly found, 
113.   but non-standard types. 
114.   """ 
115.   scheme, url = urllib.splittype(url) 
116.   if scheme == 'data': 
117.    # syntax of data URLs: 
118.    # dataurl := "data:" [ mediatype ] [ ";base64" ] "," data 
119.    # mediatype := [ type "/" subtype ] *( ";" parameter ) 
120.    # data  := *urlchar 
121.    # parameter := attribute "=" value 
122.    # type/subtype defaults to "text/plain" 
123.    comma = url.find(',') 
124.    if comma < 0: 
125.     # bad data URL 
126.     return None, None 
127.    semi = url.find(';', 0, comma) 
128.    if semi >= 0: 
129.     type = url[:semi] 
130.    else: 
131.     type = url[:comma] 
132.    if '=' in type or '/' not in type: 
133.     type = 'text/plain' 
134.    return type, None   # never compressed, so encoding is None 
135.   base, ext = posixpath.splitext(url) 
136.   while ext in self.suffix_map: 
137.    base, ext = posixpath.splitext(base + self.suffix_map[ext]) 
138.   if ext in self.encodings_map: 
139.    encoding = self.encodings_map[ext] 
140.    base, ext = posixpath.splitext(base) 
141.   else: 
142.    encoding = None 
143.   types_map = self.types_map[True] 
144.   if ext in types_map: 
145.    return types_map[ext], encoding 
146.   elif ext.lower() in types_map: 
147.    return types_map[ext.lower()], encoding 
148.   elif strict: 
149.    return None, encoding 
150.   types_map = self.types_map[False] 
151.   if ext in types_map: 
152.    return types_map[ext], encoding 
153.   elif ext.lower() in types_map: 
154.    return types_map[ext.lower()], encoding 
155.   else: 
156.    return None, encoding 
157.   
158.  def guess_all_extensions(self, type, strict=True): 
159.   """Guess the extensions for a file based on its MIME type. 
160.   
161.   Return value is a list of strings giving the possible filename 
162.   extensions, including the leading dot ('.'). The extension is not 
163.   guaranteed to have been associated with any particular data stream, 
164.   but would be mapped to the MIME type `type' by guess_type(). 
165.   
166.   Optional `strict' argument when false adds a bunch of commonly found, 
167.   but non-standard types. 
168.   """ 
169.   type = type.lower() 
170.   extensions = self.types_map_inv[True].get(type, []) 
171.   if not strict: 
172.    for ext in self.types_map_inv[False].get(type, []): 
173.     if ext not in extensions: 
174.      extensions.append(ext) 
175.   return extensions 
176.   
177.  def guess_extension(self, type, strict=True): 
178.   """Guess the extension for a file based on its MIME type. 
179.   
180.   Return value is a string giving a filename extension, 
181.   including the leading dot ('.'). The extension is not 
182.   guaranteed to have been associated with any particular data 
183.   stream, but would be mapped to the MIME type `type' by 
184.   guess_type(). If no extension can be guessed for `type', None 
185.   is returned. 
186.   
187.   Optional `strict' argument when false adds a bunch of commonly found, 
188.   but non-standard types. 
189.   """ 
190.   extensions = self.guess_all_extensions(type, strict) 
191.   if not extensions: 
192.    return None 
193.   return extensions[0] 
194.   
195.  def read(self, filename, strict=True): 
196.   """ 
197.   Read a single mime.types-format file, specified by pathname. 
198.   
199.   If strict is true, information will be added to 
200.   list of standard types, else to the list of non-standard 
201.   types. 
202.   """ 
203.   with open(filename) as fp: 
204.    self.readfp(fp, strict) 
205.   
206.  def readfp(self, fp, strict=True): 
207.   """ 
208.   Read a single mime.types-format file. 
209.   
210.   If strict is true, information will be added to 
211.   list of standard types, else to the list of non-standard 
212.   types. 
213.   """ 
214.   while 1: 
215.    line = fp.readline() 
216.    if not line: 
217.     break 
218.    words = line.split() 
219.    for i in range(len(words)): 
220.     if words[i][0] == '#': 
221.      del words[i:] 
222.      break 
223.    if not words: 
224.     continue 
225.    type, suffixes = words[0], words[1:] 
226.    for suff in suffixes: 
227.     self.add_type(type, '.' + suff, strict) 
228.   
229.  def read_windows_registry(self, strict=True): 
230.   """ 
231.   Load the MIME types database from Windows registry. 
232.   
233.   If strict is true, information will be added to 
234.   list of standard types, else to the list of non-standard 
235.   types. 
236.   """ 
237.   
238.   # Windows only 
239.   if not _winreg: 
240.    return 
241.   
242.   def enum_types(mimedb): 
243.    for i in count(): 
244.     try: 
245.      yield _winreg.EnumKey(mimedb, i) 
246.     except EnvironmentError: 
247.      break 
248.   
249.   default_encoding = sys.getdefaultencoding() 
250.   with _winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT, '') as hkcr: 
251.    for subkeyname in enum_types(hkcr): 
252.     try: 
253.      with _winreg.OpenKey(hkcr, subkeyname) as subkey: 
254.       # Only check file extensions 
255.       if not subkeyname.startswith("."): 
256.        continue 
257.       # raises EnvironmentError if no 'Content Type' value 
258.       mimetype, datatype = _winreg.QueryValueEx( 
259.        subkey, 'Content Type') 
260.       if datatype != _winreg.REG_SZ: 
261.        continue 
262.       try: 
263.        mimetype = mimetype.encode(default_encoding) 
264.        subkeyname = subkeyname.encode(default_encoding) 
265.       except UnicodeEncodeError: 
266.        continue 
267.       self.add_type(mimetype, subkeyname, strict) 
268.     except EnvironmentError: 
269.      continue 
270.   
271. def guess_type(url, strict=True): 
272.  """Guess the type of a file based on its URL. 
273.   
274.  Return value is a tuple (type, encoding) where type is None if the 
275.  type can't be guessed (no or unknown suffix) or a string of the 
276.  form type/subtype, usable for a MIME Content-type header; and 
277.  encoding is None for no encoding or the name of the program used 
278.  to encode (e.g. compress or gzip). The mappings are table 
279.  driven. Encoding suffixes are case sensitive; type suffixes are 
280.  first tried case sensitive, then case insensitive. 
281.   
282.  The suffixes .tgz, .taz and .tz (case sensitive!) are all mapped 
283.  to ".tar.gz". (This is table-driven too, using the dictionary 
284.  suffix_map). 
285.   
286.  Optional `strict' argument when false adds a bunch of commonly found, but 
287.  non-standard types. 
288.  """ 
289.  if _db is None: 
290.   init() 
291.  return _db.guess_type(url, strict) 
292.   
293.   
294. def guess_all_extensions(type, strict=True): 
295.  """Guess the extensions for a file based on its MIME type. 
296.   
297.  Return value is a list of strings giving the possible filename 
298.  extensions, including the leading dot ('.'). The extension is not 
299.  guaranteed to have been associated with any particular data 
300.  stream, but would be mapped to the MIME type `type' by 
301.  guess_type(). If no extension can be guessed for `type', None 
302.  is returned. 
303.   
304.  Optional `strict' argument when false adds a bunch of commonly found, 
305.  but non-standard types. 
306.  """ 
307.  if _db is None: 
308.   init() 
309.  return _db.guess_all_extensions(type, strict) 
310.   
311. def guess_extension(type, strict=True): 
312.  """Guess the extension for a file based on its MIME type. 
313.   
314.  Return value is a string giving a filename extension, including the 
315.  leading dot ('.'). The extension is not guaranteed to have been 
316.  associated with any particular data stream, but would be mapped to the 
317.  MIME type `type' by guess_type(). If no extension can be guessed for 
318.  `type', None is returned. 
319.   
320.  Optional `strict' argument when false adds a bunch of commonly found, 
321.  but non-standard types. 
322.  """ 
323.  if _db is None: 
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.  When the extension is already known, the new 
331.  type will replace the old one. When the type 
332.  is already known the extension will be added 
333.  to the list of known extensions. 
334.   
335.  If strict is true, information will be added to 
336.  list of standard types, else to the list of non-standard 
337.  types. 
338.  """ 
339.  if _db is None: 
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.  global inited, _db 
347.  inited = True # so that MimeTypes.__init__() doesn't call us again 
348.  db = MimeTypes() 
349.  if files is None: 
350.   if _winreg: 
351.    db.read_windows_registry() 
352.   files = knownfiles 
353.  for file in files: 
354.   if os.path.isfile(file): 
355.    db.read(file) 
356.  encodings_map = db.encodings_map 
357.  suffix_map = db.suffix_map 
358.  types_map = db.types_map[True] 
359.  common_types = db.types_map[False] 
360.  # Make the DB a global variable now that it is fully initialized 
361.  _db = db 
362.   
363.   
364. def read_mime_types(file): 
365.  try: 
366.   f = open(file) 
367.  except IOError: 
368.   return None 
369.  db = MimeTypes() 
370.  db.readfp(f, True) 
371.  return db.types_map[True] 
372.   
373.   
374. def _default_mime_types(): 
375.  global suffix_map 
376.  global encodings_map 
377.  global types_map 
378.  global common_types 
379.   
380.  suffix_map = { 
381.   '.tgz': '.tar.gz', 
382.   '.taz': '.tar.gz', 
383.   '.tz': '.tar.gz', 
384.   '.tbz2': '.tar.bz2', 
385.   '.txz': '.tar.xz', 
386.   } 
387.   
388.  encodings_map = { 
389.   '.gz': 'gzip', 
390.   '.Z': 'compress', 
391.   '.bz2': 'bzip2', 
392.   '.xz': 'xz', 
393.   } 
394.   
395.  # Before adding new types, make sure they are either registered with IANA, 
396.  # at http://www.isi.edu/in-notes/iana/assignments/media-types 
397.  # or extensions, i.e. using the x- prefix 
398.   
399.  # If you add to these, please keep them sorted! 
400.  types_map = { 
401.   '.a'  : 'application/octet-stream', 
402.   '.ai'  : 'application/postscript', 
403.   '.aif' : 'audio/x-aiff', 
404.   '.aifc' : 'audio/x-aiff', 
405.   '.aiff' : 'audio/x-aiff', 
406.   '.au'  : 'audio/basic', 
407.   '.avi' : 'video/x-msvideo', 
408.   '.bat' : 'text/plain', 
409.   '.bcpio' : 'application/x-bcpio', 
410.   '.bin' : 'application/octet-stream', 
411.   '.bmp' : 'image/x-ms-bmp', 
412.   '.c'  : 'text/plain', 
413.   # Duplicates
414.   '.cdf' : 'application/x-cdf', 
415.   '.cdf' : 'application/x-netcdf', 
416.   '.cpio' : 'application/x-cpio', 
417.   '.csh' : 'application/x-csh', 
418.   '.css' : 'text/css', 
419.   '.dll' : 'application/octet-stream', 
420.   '.doc' : 'application/msword', 
421.   '.dot' : 'application/msword', 
422.   '.dvi' : 'application/x-dvi', 
423.   '.eml' : 'message/rfc822', 
424.   '.eps' : 'application/postscript', 
425.   '.etx' : 'text/x-setext', 
426.   '.exe' : 'application/octet-stream', 
427.   '.gif' : 'image/gif', 
428.   '.gtar' : 'application/x-gtar', 
429.   '.h'  : 'text/plain', 
430.   '.hdf' : 'application/x-hdf', 
431.   '.htm' : 'text/html', 
432.   '.html' : 'text/html', 
433.   '.ico' : 'image/vnd.microsoft.icon', 
434.   '.ief' : 'image/ief', 
435.   '.jpe' : 'image/jpeg', 
436.   '.jpeg' : 'image/jpeg', 
437.   '.jpg' : 'image/jpeg', 
438.   '.js'  : 'application/javascript', 
439.   '.ksh' : 'text/plain', 
440.   '.latex' : 'application/x-latex', 
441.   '.m1v' : 'video/mpeg', 
442.   '.man' : 'application/x-troff-man', 
443.   '.me'  : 'application/x-troff-me', 
444.   '.mht' : 'message/rfc822', 
445.   '.mhtml' : 'message/rfc822', 
446.   '.mif' : 'application/x-mif', 
447.   '.mov' : 'video/quicktime', 
448.   '.movie' : 'video/x-sgi-movie', 
449.   '.mp2' : 'audio/mpeg', 
450.   '.mp3' : 'audio/mpeg', 
451.   '.mp4' : 'video/mp4', 
452.   '.mpa' : 'video/mpeg', 
453.   '.mpe' : 'video/mpeg', 
454.   '.mpeg' : 'video/mpeg', 
455.   '.mpg' : 'video/mpeg', 
456.   '.ms'  : 'application/x-troff-ms', 
457.   '.nc'  : 'application/x-netcdf', 
458.   '.nws' : 'message/rfc822', 
459.   '.o'  : 'application/octet-stream', 
460.   '.obj' : 'application/octet-stream', 
461.   '.oda' : 'application/oda', 
462.   '.p12' : 'application/x-pkcs12', 
463.   '.p7c' : 'application/pkcs7-mime', 
464.   '.pbm' : 'image/x-portable-bitmap', 
465.   '.pdf' : 'application/pdf', 
466.   '.pfx' : 'application/x-pkcs12', 
467.   '.pgm' : 'image/x-portable-graymap', 
468.   '.pl'  : 'text/plain', 
469.   '.png' : 'image/png', 
470.   '.pnm' : 'image/x-portable-anymap', 
471.   '.pot' : 'application/vnd.ms-powerpoint', 
472.   '.ppa' : 'application/vnd.ms-powerpoint', 
473.   '.ppm' : 'image/x-portable-pixmap', 
474.   '.pps' : 'application/vnd.ms-powerpoint', 
475.   '.ppt' : 'application/vnd.ms-powerpoint', 
476.   '.ps'  : 'application/postscript', 
477.   '.pwz' : 'application/vnd.ms-powerpoint', 
478.   '.py'  : 'text/x-python', 
479.   '.pyc' : 'application/x-python-code', 
480.   '.pyo' : 'application/x-python-code', 
481.   '.qt'  : 'video/quicktime', 
482.   '.ra'  : 'audio/x-pn-realaudio', 
483.   '.ram' : 'application/x-pn-realaudio', 
484.   '.ras' : 'image/x-cmu-raster', 
485.   '.rdf' : 'application/xml', 
486.   '.rgb' : 'image/x-rgb', 
487.   '.roff' : 'application/x-troff', 
488.   '.rtx' : 'text/richtext', 
489.   '.sgm' : 'text/x-sgml', 
490.   '.sgml' : 'text/x-sgml', 
491.   '.sh'  : 'application/x-sh', 
492.   '.shar' : 'application/x-shar', 
493.   '.snd' : 'audio/basic', 
494.   '.so'  : 'application/octet-stream', 
495.   '.src' : 'application/x-wais-source', 
496.   '.sv4cpio': 'application/x-sv4cpio', 
497.   '.sv4crc' : 'application/x-sv4crc', 
498.   '.swf' : 'application/x-shockwave-flash', 
499.   '.t'  : 'application/x-troff', 
500.   '.tar' : 'application/x-tar', 
501.   '.tcl' : 'application/x-tcl', 
502.   '.tex' : 'application/x-tex', 
503.   '.texi' : 'application/x-texinfo', 
504.   '.texinfo': 'application/x-texinfo', 
505.   '.tif' : 'image/tiff', 
506.   '.tiff' : 'image/tiff', 
507.   '.tr'  : 'application/x-troff', 
508.   '.tsv' : 'text/tab-separated-values', 
509.   '.txt' : 'text/plain', 
510.   '.ustar' : 'application/x-ustar', 
511.   '.vcf' : 'text/x-vcard', 
512.   '.wav' : 'audio/x-wav', 
513.   '.wiz' : 'application/msword', 
514.   '.wsdl' : 'application/xml', 
515.   '.xbm' : 'image/x-xbitmap', 
516.   '.xlb' : 'application/vnd.ms-excel', 
517.   # Duplicates
518.   '.xls' : 'application/excel', 
519.   '.xls' : 'application/vnd.ms-excel', 
520.   '.xml' : 'text/xml', 
521.   '.xpdl' : 'application/xml', 
522.   '.xpm' : 'image/x-xpixmap', 
523.   '.xsl' : 'application/xml', 
524.   '.xwd' : 'image/x-xwindowdump', 
525.   '.zip' : 'application/zip', 
526.   } 
527.   
528.  # These are non-standard types, commonly found in the wild. They will 
529.  # only match if strict=0 flag is given to the API methods. 
530.   
531.  # Please sort these too 
532.  common_types = { 
533.   '.jpg' : 'image/jpg', 
534.   '.mid' : 'audio/midi', 
535.   '.midi': 'audio/midi', 
536.   '.pct' : 'image/pict', 
537.   '.pic' : 'image/pict', 
538.   '.pict': 'image/pict', 
539.   '.rtf' : 'application/rtf', 
540.   '.xul' : 'text/xul' 
541.   } 
542.   
543.   
544. _default_mime_types() 
545.   
546.   
547. if __name__ == '__main__': 
548.  import getopt 
549.   
550.  USAGE = """\ 
551. Usage: mimetypes.py [options] type 
552.   
553. Options: 
554.  --help / -h  -- print this message and exit 
555.  --lenient / -l -- additionally search of some common, but non-standard 
556.        types. 
557.  --extension / -e -- guess extension instead of type 
558.   
559. More than one type argument may be given. 
560. """ 
561.   
562.  def usage(code, msg=''): 
563.   print USAGE 
564.   if msg: print msg 
565.   sys.exit(code) 
566.   
567.  try: 
568.   opts, args = getopt.getopt(sys.argv[1:], 'hle', 
569.          ['help', 'lenient', 'extension']) 
570.  except getopt.error, msg: 
571.   usage(1, msg) 
572.   
573.  strict = 1 
574.  extension = 0 
575.  for opt, arg in opts: 
576.   if opt in ('-h', '--help'): 
577.    usage(0) 
578.   elif opt in ('-l', '--lenient'): 
579.    strict = 0 
580.   elif opt in ('-e', '--extension'): 
581.    extension = 1 
582.  for gtype in args: 
583.   if extension: 
584.    guess = guess_extension(gtype, strict) 
585.    if not guess: print "I don't know anything about type", gtype 
586.    else: print guess 
587.   else: 
588.    guess, encoding = guess_type(gtype, strict) 
589.    if not guess: print "I don't know anything about type", gtype 
590.    else: print 'type:', guess, 'encoding:', encoding