/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/email_message.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-21 13:20:17 UTC
  • mfrom: (6733.1.1 move-errors-config)
  • Revision ID: jelmer@jelmer.uk-20170721132017-oratmmxasovq4r1q
Merge lp:~jelmer/brz/move-errors-config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/email_message.py
 
1
# Copyright (C) 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""A convenience class around email.Message and email.MIMEMultipart."""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
from email import (
 
22
    Header,
 
23
    Message,
 
24
    MIMEMultipart,
 
25
    MIMEText,
 
26
    Utils,
 
27
    )
 
28
 
 
29
from . import __version__ as _breezy_version
 
30
from .osutils import safe_unicode
 
31
from .sixish import (
 
32
    text_type,
 
33
    )
 
34
from .smtp_connection import SMTPConnection
 
35
 
 
36
 
 
37
class EmailMessage(object):
 
38
    """An email message.
 
39
 
 
40
    The constructor needs an origin address, a destination address or addresses
 
41
    and a subject, and accepts a body as well. Add additional parts to the
 
42
    message with add_inline_attachment(). Retrieve the entire formatted message
 
43
    with as_string().
 
44
 
 
45
    Headers can be accessed with get() and msg[], and modified with msg[] =.
 
46
    """
 
47
 
 
48
    def __init__(self, from_address, to_address, subject, body=None):
 
49
        """Create an email message.
 
50
 
 
51
        :param from_address: The origin address, to be put on the From header.
 
52
        :param to_address: The destination address of the message, to be put in
 
53
            the To header. Can also be a list of addresses.
 
54
        :param subject: The subject of the message.
 
55
        :param body: If given, the body of the message.
 
56
 
 
57
        All four parameters can be unicode strings or byte strings, but for the
 
58
        addresses and subject byte strings must be encoded in UTF-8. For the
 
59
        body any byte string will be accepted; if it's not ASCII or UTF-8,
 
60
        it'll be sent with charset=8-bit.
 
61
        """
 
62
        self._headers = {}
 
63
        self._body = body
 
64
        self._parts = []
 
65
 
 
66
        if isinstance(to_address, (str, text_type)):
 
67
            to_address = [ to_address ]
 
68
 
 
69
        to_addresses = []
 
70
 
 
71
        for addr in to_address:
 
72
            to_addresses.append(self.address_to_encoded_header(addr))
 
73
 
 
74
        self._headers['To'] = ', '.join(to_addresses)
 
75
        self._headers['From'] = self.address_to_encoded_header(from_address)
 
76
        self._headers['Subject'] = Header.Header(safe_unicode(subject))
 
77
        self._headers['User-Agent'] = 'Bazaar (%s)' % _breezy_version
 
78
 
 
79
    def add_inline_attachment(self, body, filename=None, mime_subtype='plain'):
 
80
        """Add an inline attachment to the message.
 
81
 
 
82
        :param body: A text to attach. Can be an unicode string or a byte
 
83
            string, and it'll be sent as ascii, utf-8, or 8-bit, in that
 
84
            preferred order.
 
85
        :param filename: The name for the attachment. This will give a default
 
86
            name for email programs to save the attachment.
 
87
        :param mime_subtype: MIME subtype of the attachment (eg. 'plain' for
 
88
            text/plain [default]).
 
89
 
 
90
        The attachment body will be displayed inline, so do not use this
 
91
        function to attach binary attachments.
 
92
        """
 
93
        # add_inline_attachment() has been called, so the message will be a
 
94
        # MIMEMultipart; add the provided body, if any, as the first attachment
 
95
        if self._body is not None:
 
96
            self._parts.append((self._body, None, 'plain'))
 
97
            self._body = None
 
98
 
 
99
        self._parts.append((body, filename, mime_subtype))
 
100
 
 
101
    def as_string(self, boundary=None):
 
102
        """Return the entire formatted message as a string.
 
103
 
 
104
        :param boundary: The boundary to use between MIME parts, if applicable.
 
105
            Used for tests.
 
106
        """
 
107
        if not self._parts:
 
108
            msgobj = Message.Message()
 
109
            if self._body is not None:
 
110
                body, encoding = self.string_with_encoding(self._body)
 
111
                msgobj.set_payload(body, encoding)
 
112
        else:
 
113
            msgobj = MIMEMultipart.MIMEMultipart()
 
114
 
 
115
            if boundary is not None:
 
116
                msgobj.set_boundary(boundary)
 
117
 
 
118
            for body, filename, mime_subtype in self._parts:
 
119
                body, encoding = self.string_with_encoding(body)
 
120
                payload = MIMEText.MIMEText(body, mime_subtype, encoding)
 
121
 
 
122
                if filename is not None:
 
123
                    content_type = payload['Content-Type']
 
124
                    content_type += '; name="%s"' % filename
 
125
                    payload.replace_header('Content-Type', content_type)
 
126
 
 
127
                payload['Content-Disposition'] = 'inline'
 
128
                msgobj.attach(payload)
 
129
 
 
130
        # sort headers here to ease testing
 
131
        for header, value in sorted(self._headers.items()):
 
132
            msgobj[header] = value
 
133
 
 
134
        return msgobj.as_string()
 
135
 
 
136
    __str__ = as_string
 
137
 
 
138
    def get(self, header, failobj=None):
 
139
        """Get a header from the message, returning failobj if not present."""
 
140
        return self._headers.get(header, failobj)
 
141
 
 
142
    def __getitem__(self, header):
 
143
        """Get a header from the message, returning None if not present.
 
144
 
 
145
        This method intentionally does not raise KeyError to mimic the behavior
 
146
        of __getitem__ in email.Message.
 
147
        """
 
148
        return self._headers.get(header, None)
 
149
 
 
150
    def __setitem__(self, header, value):
 
151
        return self._headers.__setitem__(header, value)
 
152
 
 
153
    @staticmethod
 
154
    def send(config, from_address, to_address, subject, body, attachment=None,
 
155
             attachment_filename=None, attachment_mime_subtype='plain'):
 
156
        """Create an email message and send it with SMTPConnection.
 
157
 
 
158
        :param config: config object to pass to SMTPConnection constructor.
 
159
 
 
160
        See EmailMessage.__init__() and EmailMessage.add_inline_attachment()
 
161
        for an explanation of the rest of parameters.
 
162
        """
 
163
        msg = EmailMessage(from_address, to_address, subject, body)
 
164
        if attachment is not None:
 
165
            msg.add_inline_attachment(attachment, attachment_filename,
 
166
                    attachment_mime_subtype)
 
167
        SMTPConnection(config).send_email(msg)
 
168
 
 
169
    @staticmethod
 
170
    def address_to_encoded_header(address):
 
171
        """RFC2047-encode an address if necessary.
 
172
 
 
173
        :param address: An unicode string, or UTF-8 byte string.
 
174
        :return: A possibly RFC2047-encoded string.
 
175
        """
 
176
        # Can't call Header over all the address, because that encodes both the
 
177
        # name and the email address, which is not permitted by RFCs.
 
178
        user, email = Utils.parseaddr(address)
 
179
        if not user:
 
180
            return email
 
181
        else:
 
182
            return Utils.formataddr((str(Header.Header(safe_unicode(user))),
 
183
                email))
 
184
 
 
185
    @staticmethod
 
186
    def string_with_encoding(string_):
 
187
        """Return a str object together with an encoding.
 
188
 
 
189
        :param string\\_: A str or unicode object.
 
190
        :return: A tuple (str, encoding), where encoding is one of 'ascii',
 
191
            'utf-8', or '8-bit', in that preferred order.
 
192
        """
 
193
        # Python's email module base64-encodes the body whenever the charset is
 
194
        # not explicitly set to ascii. Because of this, and because we want to
 
195
        # avoid base64 when it's not necessary in order to be most compatible
 
196
        # with the capabilities of the receiving side, we check with encode()
 
197
        # and decode() whether the body is actually ascii-only.
 
198
        if isinstance(string_, unicode):
 
199
            try:
 
200
                return (string_.encode('ascii'), 'ascii')
 
201
            except UnicodeEncodeError:
 
202
                return (string_.encode('utf-8'), 'utf-8')
 
203
        else:
 
204
            try:
 
205
                string_.decode('ascii')
 
206
                return (string_, 'ascii')
 
207
            except UnicodeDecodeError:
 
208
                try:
 
209
                    string_.decode('utf-8')
 
210
                    return (string_, 'utf-8')
 
211
                except UnicodeDecodeError:
 
212
                    return (string_, '8-bit')