home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_429 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  14.1 KB  |  505 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'Message']
  6. import re
  7. import uu
  8. import binascii
  9. import warnings
  10. from cStringIO import StringIO
  11. import email.charset as email
  12. from email import utils
  13. from email import errors
  14. SEMISPACE = '; '
  15. tspecials = re.compile('[ \\(\\)<>@,;:\\\\"/\\[\\]\\?=]')
  16.  
  17. def _splitparam(param):
  18.     (a, sep, b) = param.partition(';')
  19.     if not sep:
  20.         return (a.strip(), None)
  21.     return (a.strip(), b.strip())
  22.  
  23.  
  24. def _formatparam(param, value = None, quote = True):
  25.     if value is not None and len(value) > 0:
  26.         if isinstance(value, tuple):
  27.             param += '*'
  28.             value = utils.encode_rfc2231(value[2], value[0], value[1])
  29.         
  30.         if quote or tspecials.search(value):
  31.             return '%s="%s"' % (param, utils.quote(value))
  32.         return '%s=%s' % (param, value)
  33.     len(value) > 0
  34.     return param
  35.  
  36.  
  37. def _parseparam(s):
  38.     plist = []
  39.     while s[:1] == ';':
  40.         s = s[1:]
  41.         end = s.find(';')
  42.         while end > 0 and s.count('"', 0, end) % 2:
  43.             end = s.find(';', end + 1)
  44.         if end < 0:
  45.             end = len(s)
  46.         
  47.         f = s[:end]
  48.         if '=' in f:
  49.             i = f.index('=')
  50.             f = f[:i].strip().lower() + '=' + f[i + 1:].strip()
  51.         
  52.         plist.append(f.strip())
  53.         s = s[end:]
  54.     return plist
  55.  
  56.  
  57. def _unquotevalue(value):
  58.     if isinstance(value, tuple):
  59.         return (value[0], value[1], utils.unquote(value[2]))
  60.     return utils.unquote(value)
  61.  
  62.  
  63. class Message:
  64.     
  65.     def __init__(self):
  66.         self._headers = []
  67.         self._unixfrom = None
  68.         self._payload = None
  69.         self._charset = None
  70.         self.preamble = None
  71.         self.epilogue = None
  72.         self.defects = []
  73.         self._default_type = 'text/plain'
  74.  
  75.     
  76.     def __str__(self):
  77.         return self.as_string(unixfrom = True)
  78.  
  79.     
  80.     def as_string(self, unixfrom = False):
  81.         Generator = Generator
  82.         import email.generator
  83.         fp = StringIO()
  84.         g = Generator(fp)
  85.         g.flatten(self, unixfrom = unixfrom)
  86.         return fp.getvalue()
  87.  
  88.     
  89.     def is_multipart(self):
  90.         return isinstance(self._payload, list)
  91.  
  92.     
  93.     def set_unixfrom(self, unixfrom):
  94.         self._unixfrom = unixfrom
  95.  
  96.     
  97.     def get_unixfrom(self):
  98.         return self._unixfrom
  99.  
  100.     
  101.     def attach(self, payload):
  102.         if self._payload is None:
  103.             self._payload = [
  104.                 payload]
  105.         else:
  106.             self._payload.append(payload)
  107.  
  108.     
  109.     def get_payload(self, i = None, decode = False):
  110.         if i is None:
  111.             payload = self._payload
  112.         elif not isinstance(self._payload, list):
  113.             raise TypeError('Expected list, got %s' % type(self._payload))
  114.         else:
  115.             payload = self._payload[i]
  116.         return payload
  117.  
  118.     
  119.     def set_payload(self, payload, charset = None):
  120.         self._payload = payload
  121.         if charset is not None:
  122.             self.set_charset(charset)
  123.         
  124.  
  125.     
  126.     def set_charset(self, charset):
  127.         if charset is None:
  128.             self.del_param('charset')
  129.             self._charset = None
  130.             return None
  131.         if isinstance(charset, basestring):
  132.             charset = email.charset.Charset(charset)
  133.         
  134.         if not isinstance(charset, email.charset.Charset):
  135.             raise TypeError(charset)
  136.         isinstance(charset, email.charset.Charset)
  137.         self._charset = charset
  138.         if not self.has_key('MIME-Version'):
  139.             self.add_header('MIME-Version', '1.0')
  140.         
  141.         if not self.has_key('Content-Type'):
  142.             self.add_header('Content-Type', 'text/plain', charset = charset.get_output_charset())
  143.         else:
  144.             self.set_param('charset', charset.get_output_charset())
  145.         if str(charset) != charset.get_output_charset():
  146.             self._payload = charset.body_encode(self._payload)
  147.         
  148.         if not self.has_key('Content-Transfer-Encoding'):
  149.             cte = charset.get_body_encoding()
  150.             
  151.             try:
  152.                 cte(self)
  153.             except TypeError:
  154.                 self._payload = charset.body_encode(self._payload)
  155.                 self.add_header('Content-Transfer-Encoding', cte)
  156.             except:
  157.                 None<EXCEPTION MATCH>TypeError
  158.             
  159.  
  160.         None<EXCEPTION MATCH>TypeError
  161.  
  162.     
  163.     def get_charset(self):
  164.         return self._charset
  165.  
  166.     
  167.     def __len__(self):
  168.         return len(self._headers)
  169.  
  170.     
  171.     def __getitem__(self, name):
  172.         return self.get(name)
  173.  
  174.     
  175.     def __setitem__(self, name, val):
  176.         self._headers.append((name, val))
  177.  
  178.     
  179.     def __delitem__(self, name):
  180.         name = name.lower()
  181.         newheaders = []
  182.         for k, v in self._headers:
  183.             if k.lower() != name:
  184.                 newheaders.append((k, v))
  185.                 continue
  186.         
  187.         self._headers = newheaders
  188.  
  189.     
  190.     def __contains__(self, name):
  191.         return [] in [ k.lower() for k, v in self._headers ]
  192.  
  193.     
  194.     def has_key(self, name):
  195.         missing = object()
  196.         return self.get(name, missing) is not missing
  197.  
  198.     
  199.     def keys(self):
  200.         return [ k for k, v in self._headers ]
  201.  
  202.     
  203.     def values(self):
  204.         return [ v for k, v in self._headers ]
  205.  
  206.     
  207.     def items(self):
  208.         return self._headers[:]
  209.  
  210.     
  211.     def get(self, name, failobj = None):
  212.         name = name.lower()
  213.         for k, v in self._headers:
  214.             if k.lower() == name:
  215.                 return v
  216.         
  217.         return failobj
  218.  
  219.     
  220.     def get_all(self, name, failobj = None):
  221.         values = []
  222.         name = name.lower()
  223.         for k, v in self._headers:
  224.             if k.lower() == name:
  225.                 values.append(v)
  226.                 continue
  227.         
  228.         if not values:
  229.             return failobj
  230.         return values
  231.  
  232.     
  233.     def add_header(self, _name, _value, **_params):
  234.         parts = []
  235.         for k, v in _params.items():
  236.             if v is None:
  237.                 parts.append(k.replace('_', '-'))
  238.                 continue
  239.             parts.append(_formatparam(k.replace('_', '-'), v))
  240.         
  241.         if _value is not None:
  242.             parts.insert(0, _value)
  243.         
  244.         self._headers.append((_name, SEMISPACE.join(parts)))
  245.  
  246.     
  247.     def replace_header(self, _name, _value):
  248.         _name = _name.lower()
  249.         for k, v in zip(range(len(self._headers)), self._headers):
  250.             if k.lower() == _name:
  251.                 self._headers[i] = (k, _value)
  252.                 break
  253.                 continue
  254.         else:
  255.             raise KeyError(_name)
  256.  
  257.     
  258.     def get_content_type(self):
  259.         missing = object()
  260.         value = self.get('content-type', missing)
  261.         if value is missing:
  262.             return self.get_default_type()
  263.         ctype = _splitparam(value)[0].lower()
  264.         if ctype.count('/') != 1:
  265.             return 'text/plain'
  266.         return ctype
  267.  
  268.     
  269.     def get_content_maintype(self):
  270.         ctype = self.get_content_type()
  271.         return ctype.split('/')[0]
  272.  
  273.     
  274.     def get_content_subtype(self):
  275.         ctype = self.get_content_type()
  276.         return ctype.split('/')[1]
  277.  
  278.     
  279.     def get_default_type(self):
  280.         return self._default_type
  281.  
  282.     
  283.     def set_default_type(self, ctype):
  284.         self._default_type = ctype
  285.  
  286.     
  287.     def _get_params_preserve(self, failobj, header):
  288.         missing = object()
  289.         value = self.get(header, missing)
  290.         if value is missing:
  291.             return failobj
  292.         params = []
  293.         for p in _parseparam(';' + value):
  294.             
  295.             try:
  296.                 (name, val) = p.split('=', 1)
  297.                 name = name.strip()
  298.                 val = val.strip()
  299.             except ValueError:
  300.                 value is missing
  301.                 value is missing
  302.                 name = p.strip()
  303.                 val = ''
  304.             except:
  305.                 value is missing
  306.  
  307.             params.append((name, val))
  308.         
  309.         params = utils.decode_params(params)
  310.         return params
  311.  
  312.     
  313.     def get_params(self, failobj = None, header = 'content-type', unquote = True):
  314.         missing = object()
  315.         params = self._get_params_preserve(missing, header)
  316.         if params is missing:
  317.             return failobj
  318.         if unquote:
  319.             return [ (k, _unquotevalue(v)) for k, v in params ]
  320.         return params
  321.  
  322.     
  323.     def get_param(self, param, failobj = None, header = 'content-type', unquote = True):
  324.         if not self.has_key(header):
  325.             return failobj
  326.         for k, v in self._get_params_preserve(failobj, header):
  327.             if k.lower() == param.lower():
  328.                 if unquote:
  329.                     return _unquotevalue(v)
  330.                 return v
  331.             k.lower() == param.lower()
  332.         
  333.         return failobj
  334.  
  335.     
  336.     def set_param(self, param, value, header = 'Content-Type', requote = True, charset = None, language = ''):
  337.         if not isinstance(value, tuple) and charset:
  338.             value = (charset, language, value)
  339.         
  340.         if not self.has_key(header) and header.lower() == 'content-type':
  341.             ctype = 'text/plain'
  342.         else:
  343.             ctype = self.get(header)
  344.         if not self.get_param(param, header = header):
  345.             if not ctype:
  346.                 ctype = _formatparam(param, value, requote)
  347.             else:
  348.                 ctype = SEMISPACE.join([
  349.                     ctype,
  350.                     _formatparam(param, value, requote)])
  351.         else:
  352.             ctype = ''
  353.             for old_param, old_value in self.get_params(header = header, unquote = requote):
  354.                 append_param = ''
  355.                 if old_param.lower() == param.lower():
  356.                     append_param = _formatparam(param, value, requote)
  357.                 else:
  358.                     append_param = _formatparam(old_param, old_value, requote)
  359.                 if not ctype:
  360.                     ctype = append_param
  361.                     continue
  362.                 ctype = SEMISPACE.join([
  363.                     ctype,
  364.                     append_param])
  365.             
  366.         if ctype != self.get(header):
  367.             del self[header]
  368.             self[header] = ctype
  369.         
  370.  
  371.     
  372.     def del_param(self, param, header = 'content-type', requote = True):
  373.         if not self.has_key(header):
  374.             return None
  375.         new_ctype = ''
  376.         for p, v in self.get_params(header = header, unquote = requote):
  377.             if p.lower() != param.lower():
  378.                 if not new_ctype:
  379.                     new_ctype = _formatparam(p, v, requote)
  380.                 else:
  381.                     new_ctype = SEMISPACE.join([
  382.                         new_ctype,
  383.                         _formatparam(p, v, requote)])
  384.             new_ctype
  385.         
  386.         if new_ctype != self.get(header):
  387.             del self[header]
  388.             self[header] = new_ctype
  389.         
  390.  
  391.     
  392.     def set_type(self, type, header = 'Content-Type', requote = True):
  393.         if not type.count('/') == 1:
  394.             raise ValueError
  395.         type.count('/') == 1
  396.         if header.lower() == 'content-type':
  397.             del self['mime-version']
  398.             self['MIME-Version'] = '1.0'
  399.         
  400.         if not self.has_key(header):
  401.             self[header] = type
  402.             return None
  403.         params = self.get_params(header = header, unquote = requote)
  404.         del self[header]
  405.         self[header] = type
  406.         for p, v in params[1:]:
  407.             self.set_param(p, v, header, requote)
  408.         
  409.  
  410.     
  411.     def get_filename(self, failobj = None):
  412.         missing = object()
  413.         filename = self.get_param('filename', missing, 'content-disposition')
  414.         if filename is missing:
  415.             filename = self.get_param('name', missing, 'content-disposition')
  416.         
  417.         if filename is missing:
  418.             return failobj
  419.         return utils.collapse_rfc2231_value(filename).strip()
  420.  
  421.     
  422.     def get_boundary(self, failobj = None):
  423.         missing = object()
  424.         boundary = self.get_param('boundary', missing)
  425.         if boundary is missing:
  426.             return failobj
  427.         return utils.collapse_rfc2231_value(boundary).rstrip()
  428.  
  429.     
  430.     def set_boundary(self, boundary):
  431.         missing = object()
  432.         params = self._get_params_preserve(missing, 'content-type')
  433.         if params is missing:
  434.             raise errors.HeaderParseError('No Content-Type header found')
  435.         params is missing
  436.         newparams = []
  437.         foundp = False
  438.         for pk, pv in params:
  439.             if pk.lower() == 'boundary':
  440.                 newparams.append(('boundary', '"%s"' % boundary))
  441.                 foundp = True
  442.                 continue
  443.             newparams.append((pk, pv))
  444.         
  445.         if not foundp:
  446.             newparams.append(('boundary', '"%s"' % boundary))
  447.         
  448.         newheaders = []
  449.         for h, v in self._headers:
  450.             if h.lower() == 'content-type':
  451.                 parts = []
  452.                 for k, v in newparams:
  453.                     if v == '':
  454.                         parts.append(k)
  455.                         continue
  456.                     parts.append('%s=%s' % (k, v))
  457.                 
  458.                 newheaders.append((h, SEMISPACE.join(parts)))
  459.                 continue
  460.             newheaders.append((h, v))
  461.         
  462.         self._headers = newheaders
  463.  
  464.     
  465.     def get_content_charset(self, failobj = None):
  466.         missing = object()
  467.         charset = self.get_param('charset', missing)
  468.         if charset is missing:
  469.             return failobj
  470.         if isinstance(charset, tuple):
  471.             if not charset[0]:
  472.                 pass
  473.             pcharset = 'us-ascii'
  474.             
  475.             try:
  476.                 charset = unicode(charset[2], pcharset).encode('us-ascii')
  477.             except (LookupError, UnicodeError):
  478.                 charset is missing
  479.                 charset is missing
  480.                 charset = charset[2]
  481.             except:
  482.                 charset is missing<EXCEPTION MATCH>(LookupError, UnicodeError)
  483.             
  484.  
  485.         charset is missing
  486.         
  487.         try:
  488.             if isinstance(charset, str):
  489.                 charset = unicode(charset, 'us-ascii')
  490.             
  491.             charset = charset.encode('us-ascii')
  492.         except UnicodeError:
  493.             charset is missing
  494.             charset is missing
  495.             return failobj
  496.  
  497.         return charset.lower()
  498.  
  499.     
  500.     def get_charsets(self, failobj = None):
  501.         return [ part.get_content_charset(failobj) for part in self.walk() ]
  502.  
  503.     from email.iterators import walk
  504.  
  505.