R David Murray | 79cf3ba | 2012-05-27 17:10:36 -0400 | [diff] [blame] | 1 | :mod:`email.policy`: Policy Objects |
| 2 | ----------------------------------- |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 3 | |
| 4 | .. module:: email.policy |
| 5 | :synopsis: Controlling the parsing and generating of messages |
| 6 | |
R David Murray | 79cf3ba | 2012-05-27 17:10:36 -0400 | [diff] [blame] | 7 | .. moduleauthor:: R. David Murray <rdmurray@bitdance.com> |
| 8 | .. sectionauthor:: R. David Murray <rdmurray@bitdance.com> |
| 9 | |
Éric Araujo | 54dbfbd | 2011-08-10 21:43:13 +0200 | [diff] [blame] | 10 | .. versionadded:: 3.3 |
R David Murray | 6a45d3b | 2011-04-18 16:00:47 -0400 | [diff] [blame] | 11 | |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 12 | |
| 13 | The :mod:`email` package's prime focus is the handling of email messages as |
| 14 | described by the various email and MIME RFCs. However, the general format of |
| 15 | email messages (a block of header fields each consisting of a name followed by |
| 16 | a colon followed by a value, the whole block followed by a blank line and an |
| 17 | arbitrary 'body'), is a format that has found utility outside of the realm of |
| 18 | email. Some of these uses conform fairly closely to the main RFCs, some do |
| 19 | not. And even when working with email, there are times when it is desirable to |
| 20 | break strict compliance with the RFCs. |
| 21 | |
R David Murray | 6a45d3b | 2011-04-18 16:00:47 -0400 | [diff] [blame] | 22 | Policy objects give the email package the flexibility to handle all these |
| 23 | disparate use cases. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 24 | |
| 25 | A :class:`Policy` object encapsulates a set of attributes and methods that |
| 26 | control the behavior of various components of the email package during use. |
| 27 | :class:`Policy` instances can be passed to various classes and methods in the |
| 28 | email package to alter the default behavior. The settable values and their |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 29 | defaults are described below. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 30 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 31 | There is a default policy used by all classes in the email package. This |
| 32 | policy is named :class:`Compat32`, with a corresponding pre-defined instance |
| 33 | named :const:`compat32`. It provides for complete backward compatibility (in |
| 34 | some cases, including bug compatibility) with the pre-Python3.3 version of the |
| 35 | email package. |
| 36 | |
| 37 | The first part of this documentation covers the features of :class:`Policy`, an |
| 38 | :term:`abstract base class` that defines the features that are common to all |
| 39 | policy objects, including :const:`compat32`. This includes certain hook |
| 40 | methods that are called internally by the email package, which a custom policy |
| 41 | could override to obtain different behavior. |
| 42 | |
| 43 | When a :class:`~email.message.Message` object is created, it acquires a policy. |
| 44 | By default this will be :const:`compat32`, but a different policy can be |
| 45 | specified. If the ``Message`` is created by a :mod:`~email.parser`, a policy |
| 46 | passed to the parser will be the policy used by the ``Message`` it creates. If |
| 47 | the ``Message`` is created by the program, then the policy can be specified |
| 48 | when it is created. When a ``Message`` is passed to a :mod:`~email.generator`, |
| 49 | the generator uses the policy from the ``Message`` by default, but you can also |
| 50 | pass a specific policy to the generator that will override the one stored on |
| 51 | the ``Message`` object. |
| 52 | |
| 53 | :class:`Policy` instances are immutable, but they can be cloned, accepting the |
| 54 | same keyword arguments as the class constructor and returning a new |
| 55 | :class:`Policy` instance that is a copy of the original but with the specified |
| 56 | attributes values changed. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 57 | |
| 58 | As an example, the following code could be used to read an email message from a |
R David Murray | 6a45d3b | 2011-04-18 16:00:47 -0400 | [diff] [blame] | 59 | file on disk and pass it to the system ``sendmail`` program on a Unix system:: |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 60 | |
| 61 | >>> from email import msg_from_binary_file |
| 62 | >>> from email.generator import BytesGenerator |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 63 | >>> from subprocess import Popen, PIPE |
| 64 | >>> with open('mymsg.txt', 'b') as f: |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 65 | ... msg = msg_from_binary_file(f) |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 66 | >>> p = Popen(['sendmail', msg['To'][0].address], stdin=PIPE) |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 67 | >>> g = BytesGenerator(p.stdin, policy=msg.policy.clone(linesep='\r\n')) |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 68 | >>> g.flatten(msg) |
| 69 | >>> p.stdin.close() |
| 70 | >>> rc = p.wait() |
| 71 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 72 | Here we are telling :class:`~email.generator.BytesGenerator` to use the RFC |
| 73 | correct line separator characters when creating the binary string to feed into |
| 74 | ``sendmail's`` ``stdin``, where the default policy would use ``\n`` line |
| 75 | separators. |
Éric Araujo | fe0472e | 2011-12-03 16:00:56 +0100 | [diff] [blame] | 76 | |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 77 | Some email package methods accept a *policy* keyword argument, allowing the |
R David Murray | 6a45d3b | 2011-04-18 16:00:47 -0400 | [diff] [blame] | 78 | policy to be overridden for that method. For example, the following code uses |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 79 | the :meth:`~email.message.Message.as_string` method of the *msg* object from |
| 80 | the previous example and writes the message to a file using the native line |
| 81 | separators for the platform on which it is running:: |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 82 | |
| 83 | >>> import os |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 84 | >>> with open('converted.txt', 'wb') as f: |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 85 | ... f.write(msg.as_string(policy=msg.policy.clone(linesep=os.linesep)) |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 86 | |
| 87 | Policy objects can also be combined using the addition operator, producing a |
| 88 | policy object whose settings are a combination of the non-default values of the |
| 89 | summed objects:: |
| 90 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 91 | >>> compat_SMTP = email.policy.clone(linesep='\r\n') |
| 92 | >>> compat_strict = email.policy.clone(raise_on_defect=True) |
| 93 | >>> compat_strict_SMTP = compat_SMTP + compat_strict |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 94 | |
| 95 | This operation is not commutative; that is, the order in which the objects are |
| 96 | added matters. To illustrate:: |
| 97 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 98 | >>> policy100 = compat32.clone(max_line_length=100) |
| 99 | >>> policy80 = compat32.clone(max_line_length=80) |
| 100 | >>> apolicy = policy100 + Policy80 |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 101 | >>> apolicy.max_line_length |
| 102 | 80 |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 103 | >>> apolicy = policy80 + policy100 |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 104 | >>> apolicy.max_line_length |
| 105 | 100 |
| 106 | |
| 107 | |
| 108 | .. class:: Policy(**kw) |
| 109 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 110 | This is the :term:`abstract base class` for all policy classes. It provides |
| 111 | default implementations for a couple of trivial methods, as well as the |
| 112 | implementation of the immutability property, the :meth:`clone` method, and |
| 113 | the constructor semantics. |
| 114 | |
| 115 | The constructor of a policy class can be passed various keyword arguments. |
| 116 | The arguments that may be specified are any non-method properties on this |
| 117 | class, plus any additional non-method properties on the concrete class. A |
| 118 | value specified in the constructor will override the default value for the |
| 119 | corresponding attribute. |
| 120 | |
| 121 | This class defines the following properties, and thus values for the |
| 122 | following may be passed in the constructor of any policy class: |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 123 | |
| 124 | .. attribute:: max_line_length |
| 125 | |
| 126 | The maximum length of any line in the serialized output, not counting the |
| 127 | end of line character(s). Default is 78, per :rfc:`5322`. A value of |
| 128 | ``0`` or :const:`None` indicates that no line wrapping should be |
| 129 | done at all. |
| 130 | |
| 131 | .. attribute:: linesep |
| 132 | |
| 133 | The string to be used to terminate lines in serialized output. The |
R David Murray | 6a45d3b | 2011-04-18 16:00:47 -0400 | [diff] [blame] | 134 | default is ``\n`` because that's the internal end-of-line discipline used |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 135 | by Python, though ``\r\n`` is required by the RFCs. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 136 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 137 | .. attribute:: cte_type |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 138 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 139 | Controls the type of Content Transfer Encodings that may be or are |
| 140 | required to be used. The possible values are: |
| 141 | |
| 142 | ======== =============================================================== |
| 143 | ``7bit`` all data must be "7 bit clean" (ASCII-only). This means that |
| 144 | where necessary data will be encoded using either |
| 145 | quoted-printable or base64 encoding. |
| 146 | |
| 147 | ``8bit`` data is not constrained to be 7 bit clean. Data in headers is |
| 148 | still required to be ASCII-only and so will be encoded (see |
| 149 | 'binary_fold' below for an exception), but body parts may use |
| 150 | the ``8bit`` CTE. |
| 151 | ======== =============================================================== |
| 152 | |
| 153 | A ``cte_type`` value of ``8bit`` only works with ``BytesGenerator``, not |
| 154 | ``Generator``, because strings cannot contain binary data. If a |
| 155 | ``Generator`` is operating under a policy that specifies |
| 156 | ``cte_type=8bit``, it will act as if ``cte_type`` is ``7bit``. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 157 | |
| 158 | .. attribute:: raise_on_defect |
| 159 | |
| 160 | If :const:`True`, any defects encountered will be raised as errors. If |
| 161 | :const:`False` (the default), defects will be passed to the |
| 162 | :meth:`register_defect` method. |
| 163 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 164 | The following :class:`Policy` method is intended to be called by code using |
| 165 | the email library to create policy instances with custom settings: |
R David Murray | 6a45d3b | 2011-04-18 16:00:47 -0400 | [diff] [blame] | 166 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 167 | .. method:: clone(**kw) |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 168 | |
| 169 | Return a new :class:`Policy` instance whose attributes have the same |
| 170 | values as the current instance, except where those attributes are |
| 171 | given new values by the keyword arguments. |
| 172 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 173 | The remaining :class:`Policy` methods are called by the email package code, |
| 174 | and are not intended to be called by an application using the email package. |
| 175 | A custom policy must implement all of these methods. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 176 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 177 | .. method:: handle_defect(obj, defect) |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 178 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 179 | Handle a *defect* found on *obj*. When the email package calls this |
| 180 | method, *defect* will always be a subclass of |
| 181 | :class:`~email.errors.Defect`. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 182 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 183 | The default implementation checks the :attr:`raise_on_defect` flag. If |
| 184 | it is ``True``, *defect* is raised as an exception. If it is ``False`` |
| 185 | (the default), *obj* and *defect* are passed to :meth:`register_defect`. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 186 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 187 | .. method:: register_defect(obj, defect) |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 188 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 189 | Register a *defect* on *obj*. In the email package, *defect* will always |
| 190 | be a subclass of :class:`~email.errors.Defect`. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 191 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 192 | The default implementation calls the ``append`` method of the ``defects`` |
| 193 | attribute of *obj*. When the email package calls :attr:`handle_defect`, |
| 194 | *obj* will normally have a ``defects`` attribute that has an ``append`` |
| 195 | method. Custom object types used with the email package (for example, |
| 196 | custom ``Message`` objects) should also provide such an attribute, |
| 197 | otherwise defects in parsed messages will raise unexpected errors. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 198 | |
R David Murray | abfc374 | 2012-05-29 09:14:44 -0400 | [diff] [blame] | 199 | .. method:: header_max_count(name) |
| 200 | |
| 201 | Return the maximum allowed number of headers named *name*. |
| 202 | |
| 203 | Called when a header is added to a :class:`~email.message.Message` |
| 204 | object. If the returned value is not ``0`` or ``None``, and there are |
| 205 | already a number of headers with the name *name* equal to the value |
| 206 | returned, a :exc:`ValueError` is raised. |
| 207 | |
| 208 | Because the default behavior of ``Message.__setitem__`` is to append the |
| 209 | value to the list of headers, it is easy to create duplicate headers |
| 210 | without realizing it. This method allows certain headers to be limited |
| 211 | in the number of instances of that header that may be added to a |
| 212 | ``Message`` programmatically. (The limit is not observed by the parser, |
| 213 | which will faithfully produce as many headers as exist in the message |
| 214 | being parsed.) |
| 215 | |
| 216 | The default implementation returns ``None`` for all header names. |
| 217 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 218 | .. method:: header_source_parse(sourcelines) |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 219 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 220 | The email package calls this method with a list of strings, each string |
| 221 | ending with the line separation characters found in the source being |
| 222 | parsed. The first line includes the field header name and separator. |
| 223 | All whitespace in the source is preserved. The method should return the |
| 224 | ``(name, value)`` tuple that is to be stored in the ``Message`` to |
| 225 | represent the parsed header. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 226 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 227 | If an implementation wishes to retain compatibility with the existing |
| 228 | email package policies, *name* should be the case preserved name (all |
| 229 | characters up to the '``:``' separator), while *value* should be the |
| 230 | unfolded value (all line separator characters removed, but whitespace |
| 231 | kept intact), stripped of leading whitespace. |
R David Murray | 3edd22a | 2011-04-18 13:59:37 -0400 | [diff] [blame] | 232 | |
R David Murray | c27e522 | 2012-05-25 15:01:48 -0400 | [diff] [blame] | 233 | *sourcelines* may contain surrogateescaped binary data. |
| 234 | |
| 235 | There is no default implementation |
| 236 | |
| 237 | .. method:: header_store_parse(name, value) |
| 238 | |
| 239 | The email package calls this method with the name and value provided by |
| 240 | the application program when the application program is modifying a |
| 241 | ``Message`` programmatically (as opposed to a ``Message`` created by a |
| 242 | parser). The method should return the ``(name, value)`` tuple that is to |
| 243 | be stored in the ``Message`` to represent the header. |
| 244 | |
| 245 | If an implementation wishes to retain compatibility with the existing |
| 246 | email package policies, the *name* and *value* should be strings or |
| 247 | string subclasses that do not change the content of the passed in |
| 248 | arguments. |
| 249 | |
| 250 | There is no default implementation |
| 251 | |
| 252 | .. method:: header_fetch_parse(name, value) |
| 253 | |
| 254 | The email package calls this method with the *name* and *value* currently |
| 255 | stored in the ``Message`` when that header is requested by the |
| 256 | application program, and whatever the method returns is what is passed |
| 257 | back to the application as the value of the header being retrieved. |
| 258 | Note that there may be more than one header with the same name stored in |
| 259 | the ``Message``; the method is passed the specific name and value of the |
| 260 | header destined to be returned to the application. |
| 261 | |
| 262 | *value* may contain surrogateescaped binary data. There should be no |
| 263 | surrogateescaped binary data in the value returned by the method. |
| 264 | |
| 265 | There is no default implementation |
| 266 | |
| 267 | .. method:: fold(name, value) |
| 268 | |
| 269 | The email package calls this method with the *name* and *value* currently |
| 270 | stored in the ``Message`` for a given header. The method should return a |
| 271 | string that represents that header "folded" correctly (according to the |
| 272 | policy settings) by composing the *name* with the *value* and inserting |
| 273 | :attr:`linesep` characters at the appropriate places. See :rfc:`5322` |
| 274 | for a discussion of the rules for folding email headers. |
| 275 | |
| 276 | *value* may contain surrogateescaped binary data. There should be no |
| 277 | surrogateescaped binary data in the string returned by the method. |
| 278 | |
| 279 | .. method:: fold_binary(name, value) |
| 280 | |
| 281 | The same as :meth:`fold`, except that the returned value should be a |
| 282 | bytes object rather than a string. |
| 283 | |
| 284 | *value* may contain surrogateescaped binary data. These could be |
| 285 | converted back into binary data in the returned bytes object. |
| 286 | |
| 287 | |
| 288 | .. class:: Compat32(**kw) |
| 289 | |
| 290 | This concrete :class:`Policy` is the backward compatibility policy. It |
| 291 | replicates the behavior of the email package in Python 3.2. The |
| 292 | :mod:`policy` module also defines an instance of this class, |
| 293 | :const:`compat32`, that is used as the default policy. Thus the default |
| 294 | behavior of the email package is to maintain compatibility with Python 3.2. |
| 295 | |
| 296 | The class provides the following concrete implementations of the |
| 297 | abstract methods of :class:`Policy`: |
| 298 | |
| 299 | .. method:: header_source_parse(sourcelines) |
| 300 | |
| 301 | The name is parsed as everything up to the '``:``' and returned |
| 302 | unmodified. The value is determined by stripping leading whitespace off |
| 303 | the remainder of the first line, joining all subsequent lines together, |
| 304 | and stripping any trailing carriage return or linefeed characters. |
| 305 | |
| 306 | .. method:: header_store_parse(name, value) |
| 307 | |
| 308 | The name and value are returned unmodified. |
| 309 | |
| 310 | .. method:: header_fetch_parse(name, value) |
| 311 | |
| 312 | If the value contains binary data, it is converted into a |
| 313 | :class:`~email.header.Header` object using the ``unknown-8bit`` charset. |
| 314 | Otherwise it is returned unmodified. |
| 315 | |
| 316 | .. method:: fold(name, value) |
| 317 | |
| 318 | Headers are folded using the :class:`~email.header.Header` folding |
| 319 | algorithm, which preserves existing line breaks in the value, and wraps |
| 320 | each resulting line to the ``max_line_length``. Non-ASCII binary data are |
| 321 | CTE encoded using the ``unknown-8bit`` charset. |
| 322 | |
| 323 | .. method:: fold_binary(name, value) |
| 324 | |
| 325 | Headers are folded using the :class:`~email.header.Header` folding |
| 326 | algorithm, which preserves existing line breaks in the value, and wraps |
| 327 | each resulting line to the ``max_line_length``. If ``cte_type`` is |
| 328 | ``7bit``, non-ascii binary data is CTE encoded using the ``unknown-8bit`` |
| 329 | charset. Otherwise the original source header is used, with its existing |
Terry Jan Reedy | 0f84764 | 2013-03-11 18:34:00 -0400 | [diff] [blame] | 330 | line breaks and any (RFC invalid) binary data it may contain. |
R David Murray | 0b6f6c8 | 2012-05-25 18:42:14 -0400 | [diff] [blame] | 331 | |
| 332 | |
| 333 | .. note:: |
| 334 | |
R David Murray | ea97668 | 2012-05-27 15:03:38 -0400 | [diff] [blame] | 335 | The documentation below describes new policies that are included in the |
| 336 | standard library on a :term:`provisional basis <provisional package>`. |
| 337 | Backwards incompatible changes (up to and including removal of the feature) |
| 338 | may occur if deemed necessary by the core developers. |
R David Murray | 0b6f6c8 | 2012-05-25 18:42:14 -0400 | [diff] [blame] | 339 | |
| 340 | |
| 341 | .. class:: EmailPolicy(**kw) |
| 342 | |
| 343 | This concrete :class:`Policy` provides behavior that is intended to be fully |
| 344 | compliant with the current email RFCs. These include (but are not limited |
| 345 | to) :rfc:`5322`, :rfc:`2047`, and the current MIME RFCs. |
| 346 | |
| 347 | This policy adds new header parsing and folding algorithms. Instead of |
| 348 | simple strings, headers are custom objects with custom attributes depending |
| 349 | on the type of the field. The parsing and folding algorithm fully implement |
| 350 | :rfc:`2047` and :rfc:`5322`. |
| 351 | |
| 352 | In addition to the settable attributes listed above that apply to all |
| 353 | policies, this policy adds the following additional attributes: |
| 354 | |
| 355 | .. attribute:: refold_source |
| 356 | |
| 357 | If the value for a header in the ``Message`` object originated from a |
| 358 | :mod:`~email.parser` (as opposed to being set by a program), this |
| 359 | attribute indicates whether or not a generator should refold that value |
| 360 | when transforming the message back into stream form. The possible values |
| 361 | are: |
| 362 | |
| 363 | ======== =============================================================== |
| 364 | ``none`` all source values use original folding |
| 365 | |
| 366 | ``long`` source values that have any line that is longer than |
| 367 | ``max_line_length`` will be refolded |
| 368 | |
| 369 | ``all`` all values are refolded. |
| 370 | ======== =============================================================== |
| 371 | |
| 372 | The default is ``long``. |
| 373 | |
| 374 | .. attribute:: header_factory |
| 375 | |
| 376 | A callable that takes two arguments, ``name`` and ``value``, where |
| 377 | ``name`` is a header field name and ``value`` is an unfolded header field |
R David Murray | ea97668 | 2012-05-27 15:03:38 -0400 | [diff] [blame] | 378 | value, and returns a string subclass that represents that header. A |
| 379 | default ``header_factory`` (see :mod:`~email.headerregistry`) is provided |
| 380 | that understands some of the :RFC:`5322` header field types. (Currently |
| 381 | address fields and date fields have special treatment, while all other |
| 382 | fields are treated as unstructured. This list will be completed before |
| 383 | the extension is marked stable.) |
R David Murray | 0b6f6c8 | 2012-05-25 18:42:14 -0400 | [diff] [blame] | 384 | |
| 385 | The class provides the following concrete implementations of the abstract |
| 386 | methods of :class:`Policy`: |
| 387 | |
R David Murray | abfc374 | 2012-05-29 09:14:44 -0400 | [diff] [blame] | 388 | .. method:: header_max_count(name) |
| 389 | |
| 390 | Returns the value of the |
| 391 | :attr:`~email.headerregistry.BaseHeader.max_count` attribute of the |
| 392 | specialized class used to represent the header with the given name. |
| 393 | |
R David Murray | 0b6f6c8 | 2012-05-25 18:42:14 -0400 | [diff] [blame] | 394 | .. method:: header_source_parse(sourcelines) |
| 395 | |
| 396 | The implementation of this method is the same as that for the |
| 397 | :class:`Compat32` policy. |
| 398 | |
| 399 | .. method:: header_store_parse(name, value) |
| 400 | |
| 401 | The name is returned unchanged. If the input value has a ``name`` |
| 402 | attribute and it matches *name* ignoring case, the value is returned |
| 403 | unchanged. Otherwise the *name* and *value* are passed to |
| 404 | ``header_factory``, and the resulting custom header object is returned as |
| 405 | the value. In this case a ``ValueError`` is raised if the input value |
| 406 | contains CR or LF characters. |
| 407 | |
| 408 | .. method:: header_fetch_parse(name, value) |
| 409 | |
| 410 | If the value has a ``name`` attribute, it is returned to unmodified. |
| 411 | Otherwise the *name*, and the *value* with any CR or LF characters |
| 412 | removed, are passed to the ``header_factory``, and the resulting custom |
| 413 | header object is returned. Any surrogateescaped bytes get turned into |
| 414 | the unicode unknown-character glyph. |
| 415 | |
| 416 | .. method:: fold(name, value) |
| 417 | |
| 418 | Header folding is controlled by the :attr:`refold_source` policy setting. |
| 419 | A value is considered to be a 'source value' if and only if it does not |
| 420 | have a ``name`` attribute (having a ``name`` attribute means it is a |
| 421 | header object of some sort). If a source value needs to be refolded |
| 422 | according to the policy, it is converted into a custom header object by |
| 423 | passing the *name* and the *value* with any CR and LF characters removed |
| 424 | to the ``header_factory``. Folding of a custom header object is done by |
| 425 | calling its ``fold`` method with the current policy. |
| 426 | |
| 427 | Source values are split into lines using :meth:`~str.splitlines`. If |
| 428 | the value is not to be refolded, the lines are rejoined using the |
| 429 | ``linesep`` from the policy and returned. The exception is lines |
| 430 | containing non-ascii binary data. In that case the value is refolded |
| 431 | regardless of the ``refold_source`` setting, which causes the binary data |
| 432 | to be CTE encoded using the ``unknown-8bit`` charset. |
| 433 | |
| 434 | .. method:: fold_binary(name, value) |
| 435 | |
| 436 | The same as :meth:`fold` if :attr:`cte_type` is ``7bit``, except that |
| 437 | the returned value is bytes. |
| 438 | |
| 439 | If :attr:`cte_type` is ``8bit``, non-ASCII binary data is converted back |
| 440 | into bytes. Headers with binary data are not refolded, regardless of the |
| 441 | ``refold_header`` setting, since there is no way to know whether the |
| 442 | binary data consists of single byte characters or multibyte characters. |
| 443 | |
| 444 | The following instances of :class:`EmailPolicy` provide defaults suitable for |
| 445 | specific application domains. Note that in the future the behavior of these |
Georg Brandl | 38e0e1e | 2012-05-27 09:31:10 +0200 | [diff] [blame] | 446 | instances (in particular the ``HTTP`` instance) may be adjusted to conform even |
R David Murray | 0b6f6c8 | 2012-05-25 18:42:14 -0400 | [diff] [blame] | 447 | more closely to the RFCs relevant to their domains. |
| 448 | |
| 449 | .. data:: default |
| 450 | |
| 451 | An instance of ``EmailPolicy`` with all defaults unchanged. This policy |
| 452 | uses the standard Python ``\n`` line endings rather than the RFC-correct |
| 453 | ``\r\n``. |
| 454 | |
| 455 | .. data:: SMTP |
| 456 | |
| 457 | Suitable for serializing messages in conformance with the email RFCs. |
| 458 | Like ``default``, but with ``linesep`` set to ``\r\n``, which is RFC |
| 459 | compliant. |
| 460 | |
| 461 | .. data:: HTTP |
| 462 | |
| 463 | Suitable for serializing headers with for use in HTTP traffic. Like |
| 464 | ``SMTP`` except that ``max_line_length`` is set to ``None`` (unlimited). |
| 465 | |
| 466 | .. data:: strict |
| 467 | |
| 468 | Convenience instance. The same as ``default`` except that |
| 469 | ``raise_on_defect`` is set to ``True``. This allows any policy to be made |
| 470 | strict by writing:: |
| 471 | |
| 472 | somepolicy + policy.strict |
| 473 | |
| 474 | With all of these :class:`EmailPolicies <.EmailPolicy>`, the effective API of |
| 475 | the email package is changed from the Python 3.2 API in the following ways: |
| 476 | |
| 477 | * Setting a header on a :class:`~email.message.Message` results in that |
| 478 | header being parsed and a custom header object created. |
| 479 | |
| 480 | * Fetching a header value from a :class:`~email.message.Message` results |
| 481 | in that header being parsed and a custom header object created and |
| 482 | returned. |
| 483 | |
| 484 | * Any custom header object, or any header that is refolded due to the |
| 485 | policy settings, is folded using an algorithm that fully implements the |
| 486 | RFC folding algorithms, including knowing where encoded words are required |
| 487 | and allowed. |
| 488 | |
| 489 | From the application view, this means that any header obtained through the |
| 490 | :class:`~email.message.Message` is a custom header object with custom |
| 491 | attributes, whose string value is the fully decoded unicode value of the |
| 492 | header. Likewise, a header may be assigned a new value, or a new header |
| 493 | created, using a unicode string, and the policy will take care of converting |
| 494 | the unicode string into the correct RFC encoded form. |
| 495 | |
R David Murray | ea97668 | 2012-05-27 15:03:38 -0400 | [diff] [blame] | 496 | The custom header objects and their attributes are described in |
| 497 | :mod:`~email.headerregistry`. |