[1.6.x] Introduced as_bytes for SafeMIMEText (and other SafeMIME-classes).

This is to provide a consistent interface (namely bytes) for the smtp
backend which after all sends bytes over the wire; encoding with as_string
yields different results since mails as unicode are not really specified.

as_string stays for backwardscompatibilty mostly and some debug outputs.
But keep in mind that the output doesn't match as_bytes!

Backport of 5dfd824d38 from master.

django/core/mail/backends/smtp.py

@@ -7,7 +7,6 @@ from django.conf import settings
 from django.core.mail.backends.base import BaseEmailBackend
 from django.core.mail.utils import DNS_NAME
 from django.core.mail.message import sanitize_address
-from django.utils.encoding import force_bytes
 
 
 class EmailBackend(BaseEmailBackend):
@@ -107,11 +106,9 @@ class EmailBackend(BaseEmailBackend):
         recipients = [sanitize_address(addr, email_message.encoding)
                       for addr in email_message.recipients()]
         message = email_message.message()
-        charset = message.get_charset().get_output_charset() if message.get_charset() else 'utf-8'
         try:
-            self.connection.sendmail(from_email, recipients,
-                    force_bytes(message.as_string(), charset))
-        except:
+            self.connection.sendmail(from_email, recipients, message.as_bytes())
+        except smtplib.SMTPException:
             if not self.fail_silently:
                 raise
             return False

django/core/mail/message.py

@@ -130,21 +130,25 @@ class MIMEMixin():
         This overrides the default as_string() implementation to not mangle
         lines that begin with 'From '. See bug #13433 for details.
         """
-        # Using a normal Generator on python 3 will yield a string, which will
-        # get base64 encoded in some cases to ensure that it's always convertable
-        # to ascii. We don't want base64 encoded emails, so we use a BytesGenertor
-        # which will do the right thing and then decode according to our known
-        # encoding. See #21093 and #3472 for details.
-        if six.PY3 and sys.version_info >= (3, 3, 3):
+        fp = six.StringIO()
+        g = generator.Generator(fp, mangle_from_=False)
+        g.flatten(self, unixfrom=unixfrom)
+        return fp.getvalue()
+
+    if six.PY2:
+        as_bytes = as_string
+    else:
+        def as_bytes(self, unixfrom=False):
+            """Return the entire formatted message as bytes.
+            Optional `unixfrom' when True, means include the Unix From_ envelope
+            header.
+
+            This overrides the default as_bytes() implementation to not mangle
+            lines that begin with 'From '. See bug #13433 for details.
+            """
             fp = six.BytesIO()
             g = generator.BytesGenerator(fp, mangle_from_=False)
             g.flatten(self, unixfrom=unixfrom)
-            encoding = self.get_charset().get_output_charset() if self.get_charset() else 'utf-8'
-            return fp.getvalue().decode(encoding)
-        else:
-            fp = six.StringIO()
-            g = generator.Generator(fp, mangle_from_=False)
-            g.flatten(self, unixfrom=unixfrom)
             return fp.getvalue()
 
 
@@ -158,9 +162,8 @@ class SafeMIMEText(MIMEMixin, MIMEText):
             # We do it manually and trigger re-encoding of the payload.
             MIMEText.__init__(self, text, subtype, None)
             del self['Content-Transfer-Encoding']
-            # Work around a bug in python 3.3.3 [sic], see
-            # http://bugs.python.org/issue19063 for details.
-            if sys.version_info[:3] == (3, 3, 3):
+            # Workaround for versions without http://bugs.python.org/issue19063
+            if (3, 2) < sys.version_info < (3, 3, 4):
                 payload = text.encode(utf8_charset.output_charset)
                 self._payload = payload.decode('ascii', 'surrogateescape')
                 self.set_charset(utf8_charset)