Revert "Revert "pylint: upgrade to 1.3.1""

third_party/logilab/common/umessage.py

-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of logilab-common.
 #
 # logilab-common is free software: you can redistribute it and/or modify it under
 # the terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 2.1 of the License, or (at your option) any
 # later version.
 #
 # logilab-common is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 # details.
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Unicode email support (extends email from stdlib).
+"""Unicode email support (extends email from stdlib)"""
 
-
-
-
-"""
 __docformat__ = "restructuredtext en"
 
 import email
 from encodings import search_function
 import sys
 if sys.version_info >= (2, 5):
     from email.utils import parseaddr, parsedate
     from email.header import decode_header
 else:
     from email.Utils import parseaddr, parsedate
     from email.Header import decode_header
 
 from datetime import datetime
 
 try:
     from mx.DateTime import DateTime
 except ImportError:
     DateTime = datetime
 
 import logilab.common as lgc
 
 
 def decode_QP(string):
     parts = []
     for decoded, charset in decode_header(string):
         if not charset :
             charset = 'iso-8859-15'
-        parts.append(unicode(decoded, charset, 'replace'))
+        parts.append(decoded.decode(charset, 'replace'))
 
-    return u' '.join(parts)
+    if sys.version_info < (3, 3):
+        # decoding was non-RFC compliant wrt to whitespace handling
+        # see http://bugs.python.org/issue1079
+        return u' '.join(parts)
+    return u''.join(parts)
 
 def message_from_file(fd):
     try:
         return UMessage(email.message_from_file(fd))
     except email.Errors.MessageParseError:
         return ''
 
 def message_from_string(string):
     try:
         return UMessage(email.message_from_string(string))
     except email.Errors.MessageParseError:
         return ''
 
 class UMessage:
     """Encapsulates an email.Message instance and returns only unicode objects.
     """
 
     def __init__(self, message):
         self.message = message
 
     # email.Message interface #################################################
 
     def get(self, header, default=None):
         value = self.message.get(header, default)
         if value:
             return decode_QP(value)
         return value
 
+    def __getitem__(self, header):
+        return self.get(header)
+
     def get_all(self, header, default=()):
         return [decode_QP(val) for val in self.message.get_all(header, default)
                 if val is not None]
 
-    def get_payload(self, index=None, decode=False):
-        message = self.message
-        if index is None:
-            payload = message.get_payload(index, decode)
-            if isinstance(payload, list):
-                return [UMessage(msg) for msg in payload]
-            if message.get_content_maintype() != 'text':
-                return payload
-
-            charset = message.get_content_charset() or 'iso-8859-1'
-            if search_function(charset) is None:
-                charset = 'iso-8859-1'
-            return unicode(payload or '', charset, "replace")
-        else:
-            payload = UMessage(message.get_payload(index, decode))
-        return payload
-
     def is_multipart(self):
         return self.message.is_multipart()
 
     def get_boundary(self):
         return self.message.get_boundary()
 
     def walk(self):
         for part in self.message.walk():
             yield UMessage(part)
 
-    def get_content_maintype(self):
-        return unicode(self.message.get_content_maintype())
+    if sys.version_info < (3, 0):
 
-    def get_content_type(self):
-        return unicode(self.message.get_content_type())
+        def get_payload(self, index=None, decode=False):
+            message = self.message
+            if index is None:
+                payload = message.get_payload(index, decode)
+                if isinstance(payload, list):
+                    return [UMessage(msg) for msg in payload]
+                if message.get_content_maintype() != 'text':
+                    return payload
 
-    def get_filename(self, failobj=None):
-        value = self.message.get_filename(failobj)
-        if value is failobj:
-            return value
-        try:
-            return unicode(value)
-        except UnicodeDecodeError:
-            return u'error decoding filename'
+                charset = message.get_content_charset() or 'iso-8859-1'
+                if search_function(charset) is None:
+                    charset = 'iso-8859-1'
+                return unicode(payload or '', charset, "replace")
+            else:
+                payload = UMessage(message.get_payload(index, decode))
+            return payload
+
+        def get_content_maintype(self):
+            return unicode(self.message.get_content_maintype())
+
+        def get_content_type(self):
+            return unicode(self.message.get_content_type())
+
+        def get_filename(self, failobj=None):
+            value = self.message.get_filename(failobj)
+            if value is failobj:
+                return value
+            try:
+                return unicode(value)
+            except UnicodeDecodeError:
+                return u'error decoding filename'
+
+    else:
+
+        def get_payload(self, index=None, decode=False):
+            message = self.message
+            if index is None:
+                payload = message.get_payload(index, decode)
+                if isinstance(payload, list):
+                    return [UMessage(msg) for msg in payload]
+                return payload
+            else:
+                payload = UMessage(message.get_payload(index, decode))
+            return payload
+
+        def get_content_maintype(self):
+            return self.message.get_content_maintype()
+
+        def get_content_type(self):
+            return self.message.get_content_type()
+
+        def get_filename(self, failobj=None):
+            return self.message.get_filename(failobj)
 
     # other convenience methods ###############################################
 
     def headers(self):
         """return an unicode string containing all the message's headers"""
         values = []
         for header in self.message.keys():
             values.append(u'%s: %s' % (header, self.get(header)))
         return '\n'.join(values)
 
@@ skipping 21 matching lines @@
                     pass
         if value is not None:
             datetuple = parsedate(value)
             if datetuple:
                 if lgc.USE_MX_DATETIME:
                     return DateTime(*datetuple[:6])
                 return datetime(*datetuple[:6])
             elif not return_str:
                 return None
         return value