email.policy
：策略对象
¶
3.3 版新增。
源代码： Lib/email/policy.py
email
包的首要焦点是处理由各种 Email 和 MIME RFC 所描述的 Email 消息。不管怎样，Email 消息的一般格式 (每个头字段由名称之后紧跟冒号和值组成的 Header 头字段块，整个块之后紧跟空行和任意本体)，是在 Email 界之外找到实用格式。其中一些的用法与主要电子邮件 RFC 相当接近，有些则不。即使在处理 Email 时，有时也期望打破对 RFC 的严格遵从，譬如：生成本身不遵循标准 Email 服务器互操作的电子邮件，或按违反标准的方式实现想要使用的扩展。
策略对象赋予 email 包灵活处理所有这些迥然不同的用例。
Policy
对象封装了一组属性和方法，用于控制 email 包在使用期间各个组件的行为。
Policy
实例可以将各种类和方法传入 email 包以改变其默认行为。可设置的值及其默认值的描述见下文。
email 包中的所有类都使用默认策略。对于所有的
parser
类和相关方便函数，和对于
Message
类，这是
Compat32
策略，凭借其相应预定义实例
compat32
。此策略提供对 email 包 Python 3.3 之前版本的完全向后兼容性 (在某些情况下，包括 Bug 兼容性)。
此默认值为
policy
关键词到
EmailMessage
是
EmailPolicy
策略，凭借其预定义实例
default
.
当
Message
or
EmailMessage
object is created, it acquires a policy. If the message is created by a
parser
, a policy passed to the parser will be the policy used by the message it creates. If the message is created by the program, then the policy can be specified when it is created. When a message is passed to a
generator
, the generator uses the policy from the message by default, but you can also pass a specific policy to the generator that will override the one stored on the message object.
默认值对于
policy
keyword for the
email.parser
classes and the parser convenience functions
will be changing
in a future version of Python. Therefore you should
always specify explicitly which policy you want to use
when calling any of the classes and functions described in the
parser
模块。
The first part of this documentation covers the features of
Policy
，
抽象基类
that defines the features that are common to all policy objects, including
compat32
. This includes certain hook methods that are called internally by the email package, which a custom policy could override to obtain different behavior. The second part describes the concrete classes
EmailPolicy
and
Compat32
, which implement the hooks that provide the standard behavior and the backward compatible behavior and features, respectively.
Policy
instances are immutable, but they can be cloned, accepting the same keyword arguments as the class constructor and returning a new
Policy
instance that is a copy of the original but with the specified attributes values changed.
As an example, the following code could be used to read an email message from a file on disk and pass it to the system
sendmail
程序在 Unix 系统：
>>> from email import message_from_binary_file
>>> from email.generator import BytesGenerator
>>> from email import policy
>>> from subprocess import Popen, PIPE
>>> with open('mymsg.txt', 'rb') as f:
... msg = message_from_binary_file(f, policy=policy.default)
>>> p = Popen(['sendmail', msg['To'].addresses[0]], stdin=PIPE)
>>> g = BytesGenerator(p.stdin, policy=msg.policy.clone(linesep='\r\n'))
>>> g.flatten(msg)
>>> p.stdin.close()
>>> rc = p.wait()
Here we are telling
BytesGenerator
to use the RFC correct line separator characters when creating the binary string to feed into
sendmail's
stdin
, where the default policy would use
\n
line separators.
Some email package methods accept a
policy
keyword argument, allowing the policy to be overridden for that method. For example, the following code uses the
as_bytes()
方法在
msg
object from the previous example and writes the message to a file using the native line separators for the platform on which it is running:
>>> import os
>>> with open('converted.txt', 'wb') as f:
... f.write(msg.as_bytes(policy=msg.policy.clone(linesep=os.linesep)))
17
Policy objects can also be combined using the addition operator, producing a policy object whose settings are a combination of the non-default values of the summed objects:
>>> compat_SMTP = policy.compat32.clone(linesep='\r\n')
>>> compat_strict = policy.compat32.clone(raise_on_defect=True)
>>> compat_strict_SMTP = compat_SMTP + compat_strict
This operation is not commutative; that is, the order in which the objects are added matters. To illustrate:
>>> policy100 = policy.compat32.clone(max_line_length=100)
>>> policy80 = policy.compat32.clone(max_line_length=80)
>>> apolicy = policy100 + policy80
>>> apolicy.max_line_length
80
>>> apolicy = policy80 + policy100
>>> apolicy.max_line_length
100
email.policy.
Policy
(
**kw
)
¶
这是
抽象基类
for all policy classes. It provides default implementations for a couple of trivial methods, as well as the implementation of the immutability property, the
clone()
方法，和构造函数语义。
The constructor of a policy class can be passed various keyword arguments. The arguments that may be specified are any non-method properties on this class, plus any additional non-method properties on the concrete class. A value specified in the constructor will override the default value for the corresponding attribute.
This class defines the following properties, and thus values for the following may be passed in the constructor of any policy class:
max_line_length
¶
The maximum length of any line in the serialized output, not counting the end of line character(s). Default is 78, per
RFC 5322
。值为
0
or
None
indicates that no line wrapping should be done at all.
linesep
¶
The string to be used to terminate lines in serialized output. The default is
\n
because that’s the internal end-of-line discipline used by Python, though
\r\n
is required by the RFCs.
cte_type
¶
Controls the type of Content Transfer Encodings that may be or are required to be used. The possible values are:
|
|
all data must be “7 bit clean” (ASCII-only). This means that where necessary data will be encoded using either quoted-printable or base64 encoding. |
|
|
data is not constrained to be 7 bit clean. Data in headers is still required to be ASCII-only and so will be encoded (see
|
A
cte_type
value of
8bit
only works with
BytesGenerator
, not
Generator
, because strings cannot contain binary data. If a
Generator
is operating under a policy that specifies
cte_type=8bit
, it will act as if
cte_type
is
7bit
.
raise_on_defect
¶
若
True
, any defects encountered will be raised as errors. If
False
(the default), defects will be passed to the
register_defect()
方法。
mangle_from_
¶
若
True
, lines starting with
“From “
in the body are escaped by putting a
>
in front of them. This parameter is used when the message is being serialized by a generator. Default:
False
.
3.5 版新增： mangle_from_ 参数。
下列
Policy
method is intended to be called by code using the email library to create policy instances with custom settings:
clone
(
**kw
)
¶
返回新的
Policy
instance whose attributes have the same values as the current instance, except where those attributes are given new values by the keyword arguments.
The remaining
Policy
methods are called by the email package code, and are not intended to be called by an application using the email package. A custom policy must implement all of these methods.
handle_defect
(
obj
,
defect
)
¶
处理
defect
found on
obj
. When the email package calls this method,
defect
will always be a subclass of
Defect
.
默认实现校验
raise_on_defect
标志。若它是
True
,
defect
被引发作为异常。若它是
False
(默认)，
obj
and
defect
被传递给
register_defect()
.
register_defect
(
obj
,
defect
)
¶
注册
defect
on
obj
. In the email package,
defect
will always be a subclass of
Defect
.
默认实现调用
append
方法在
defects
attribute of
obj
. When the email package calls
handle_defect
,
obj
will normally have a
defects
attribute that has an
append
method. Custom object types used with the email package (for example, custom
Message
objects) should also provide such an attribute, otherwise defects in parsed messages will raise unexpected errors.
header_max_count
(
name
)
¶
Return the maximum allowed number of headers named name .
Called when a header is added to an
EmailMessage
or
Message
object. If the returned value is not
0
or
None
, and there are already a number of headers with the name
name
greater than or equal to the value returned, a
ValueError
被引发。
Because the default behavior of
Message.__setitem__
is to append the value to the list of headers, it is easy to create duplicate headers without realizing it. This method allows certain headers to be limited in the number of instances of that header that may be added to a
Message
programmatically. (The limit is not observed by the parser, which will faithfully produce as many headers as exist in the message being parsed.)
默认实现返回
None
对于所有头名称。
header_source_parse
(
sourcelines
)
¶
The email package calls this method with a list of strings, each string ending with the line separation characters found in the source being parsed. The first line includes the field header name and separator. All whitespace in the source is preserved. The method should return the
(name, value)
tuple that is to be stored in the
Message
to represent the parsed header.
If an implementation wishes to retain compatibility with the existing email package policies,
name
should be the case preserved name (all characters up to the ‘
:
’ separator), while
value
should be the unfolded value (all line separator characters removed, but whitespace kept intact), stripped of leading whitespace.
sourcelines 可能包含替代转义二进制数据。
没有默认实现
header_store_parse
(
name
,
value
)
¶
The email package calls this method with the name and value provided by the application program when the application program is modifying a
Message
programmatically (as opposed to a
Message
created by a parser). The method should return the
(name, value)
tuple that is to be stored in the
Message
to represent the header.
If an implementation wishes to retain compatibility with the existing email package policies, the name and value should be strings or string subclasses that do not change the content of the passed in arguments.
没有默认实现
header_fetch_parse
(
name
,
value
)
¶
The email package calls this method with the
name
and
value
currently stored in the
Message
when that header is requested by the application program, and whatever the method returns is what is passed back to the application as the value of the header being retrieved. Note that there may be more than one header with the same name stored in the
Message
; the method is passed the specific name and value of the header destined to be returned to the application.
value may contain surrogateescaped binary data. There should be no surrogateescaped binary data in the value returned by the method.
没有默认实现
fold
(
name
,
value
)
¶
The email package calls this method with the
name
and
value
currently stored in the
Message
for a given header. The method should return a string that represents that header “folded” correctly (according to the policy settings) by composing the
name
采用
value
and inserting
linesep
characters at the appropriate places. See
RFC 5322
for a discussion of the rules for folding email headers.
value may contain surrogateescaped binary data. There should be no surrogateescaped binary data in the string returned by the method.
email.policy.
EmailPolicy
(
**kw
)
¶
此具体
Policy
provides behavior that is intended to be fully compliant with the current email RFCs. These include (but are not limited to)
RFC 5322
,
RFC 2047
, and the current MIME RFCs.
This policy adds new header parsing and folding algorithms. Instead of simple strings, headers are
str
subclasses with attributes that depend on the type of the field. The parsing and folding algorithm fully implement
RFC 2047
and
RFC 5322
.
默认值对于
message_factory
属性为
EmailMessage
.
In addition to the settable attributes listed above that apply to all policies, this policy adds the following additional attributes:
3.6 版新增： 1
utf8
¶
若
False
，遵循
RFC 5322
, supporting non-ASCII characters in headers by encoding them as “encoded words”. If
True
，遵循
RFC 6532
and use
utf-8
encoding for headers. Messages formatted in this way may be passed to SMTP servers that support the
SMTPUTF8
扩展 (
RFC 6531
).
refold_source
¶
If the value for a header in the
Message
object originated from a
parser
(as opposed to being set by a program), this attribute indicates whether or not a generator should refold that value when transforming the message back into serialized form. The possible values are:
|
|
所有源值使用原始折叠 |
|
|
source values that have any line that is longer than
|
|
|
所有值被重新折叠。 |
默认为
long
.
header_factory
¶
可调用接受 2 自变量，
name
and
value
，其中
name
是头字段名称和
value
是展开头的字段值，并返回表示该头的字符串子类。默认
header_factory
(见
headerregistry
) 提供支持自定义剖析各种地址和日期
RFC 5322
头字段类型，和主要 MIME 头字段类型。将来会添加对其它自定义剖析的支持。
content_manager
¶
An object with at least two methods: get_content and set_content. When the
get_content()
or
set_content()
方法对于
EmailMessage
object is called, it calls the corresponding method of this object, passing it the message object as its first argument, and any arguments or keywords that were passed to it as additional arguments. By default
content_manager
被设为
raw_data_manager
.
3.4 版新增。
类提供以下具体抽象方法实现对于
Policy
:
header_max_count
(
name
)
¶
返回值为
max_count
attribute of the specialized class used to represent the header with the given name.
header_source_parse
(
sourcelines
)
¶
The name is parsed as everything up to the ‘
:
’ and returned unmodified. The value is determined by stripping leading whitespace off the remainder of the first line, joining all subsequent lines together, and stripping any trailing carriage return or linefeed characters.
header_store_parse
(
name
,
value
)
¶
The name is returned unchanged. If the input value has a
name
attribute and it matches
name
ignoring case, the value is returned unchanged. Otherwise the
name
and
value
被传递给
header_factory
, and the resulting header object is returned as the value. In this case a
ValueError
is raised if the input value contains CR or LF characters.
header_fetch_parse
(
name
,
value
)
¶
若值拥有
name
attribute, it is returned to unmodified. Otherwise the
name
，和
value
with any CR or LF characters removed, are passed to the
header_factory
, and the resulting header object is returned. Any surrogateescaped bytes get turned into the unicode unknown-character glyph.
fold
(
name
,
value
)
¶
Header folding is controlled by the
refold_source
policy setting. A value is considered to be a ‘source value’ if and only if it does not have a
name
attribute (having a
name
attribute means it is a header object of some sort). If a source value needs to be refolded according to the policy, it is converted into a header object by passing the
name
和
value
with any CR and LF characters removed to the
header_factory
. Folding of a header object is done by calling its
fold
method with the current policy.
Source values are split into lines using
splitlines()
. If the value is not to be refolded, the lines are rejoined using the
linesep
from the policy and returned. The exception is lines containing non-ascii binary data. In that case the value is refolded regardless of the
refold_source
setting, which causes the binary data to be CTE encoded using the
unknown-8bit
字符集。
fold_binary
(
name
,
value
)
¶
如同
fold()
if
cte_type
is
7bit
, except that the returned value is bytes.
若
cte_type
is
8bit
, non-ASCII binary data is converted back into bytes. Headers with binary data are not refolded, regardless of the
refold_header
setting, since there is no way to know whether the binary data consists of single byte characters or multibyte characters.
The following instances of
EmailPolicy
provide defaults suitable for specific application domains. Note that in the future the behavior of these instances (in particular the
HTTP
instance) may be adjusted to conform even more closely to the RFCs relevant to their domains.
email.policy.
default
¶
实例化的
EmailPolicy
采用所有不变默认值。此策略使用标准 Python
\n
行结束而不是 RFC 正确
\r\n
.
email.policy.
SMTP
¶
Suitable for serializing messages in conformance with the email RFCs. Like
default
, but with
linesep
设为
\r\n
, which is RFC compliant.
email.policy.
SMTPUTF8
¶
如同
SMTP
除了
utf8
is
True
. Useful for serializing messages to a message store without using encoded words in the headers. Should only be used for SMTP transmission if the sender or recipient addresses have non-ASCII characters (the
smtplib.SMTP.send_message()
method handles this automatically).
email.policy.
HTTP
¶
Suitable for serializing headers with for use in HTTP traffic. Like
SMTP
除了
max_line_length
被设为
None
(unlimited).
email.policy.
strict
¶
方便实例。如同
default
除了
raise_on_defect
被设为
True
. This allows any policy to be made strict by writing:
somepolicy + policy.strict
With all of these
EmailPolicies
, the effective API of the email package is changed from the Python 3.2 API in the following ways:
Setting a header on a
Messageresults in that header being parsed and a header object created.Fetching a header value from a
Messageresults in that header being parsed and a header object created and returned.Any header object, or any header that is refolded due to the policy settings, is folded using an algorithm that fully implements the RFC folding algorithms, including knowing where encoded words are required and allowed.
From the application view, this means that any header obtained through the
EmailMessage
is a header object with extra attributes, whose string value is the fully decoded unicode value of the header. Likewise, a header may be assigned a new value, or a new header created, using a unicode string, and the policy will take care of converting the unicode string into the correct RFC encoded form.
The header objects and their attributes are described in
headerregistry
.
email.policy.
Compat32
(
**kw
)
¶
此具体
Policy
is the backward compatibility policy. It replicates the behavior of the email package in Python 3.2. The
policy
module also defines an instance of this class,
compat32
, that is used as the default policy. Thus the default behavior of the email package is to maintain compatibility with Python 3.2.
The following attributes have values that are different from the
Policy
默认：
mangle_from_
¶
默认为
True
.
类提供以下具体抽象方法实现对于
Policy
:
header_source_parse
(
sourcelines
)
¶
The name is parsed as everything up to the ‘
:
’ and returned unmodified. The value is determined by stripping leading whitespace off the remainder of the first line, joining all subsequent lines together, and stripping any trailing carriage return or linefeed characters.
header_store_parse
(
name
,
value
)
¶
不修改返回名称和值。
fold
(
name
,
value
)
¶
Headers are folded using the
Header
folding algorithm, which preserves existing line breaks in the value, and wraps each resulting line to the
max_line_length
. Non-ASCII binary data are CTE encoded using the
unknown-8bit
字符集。
fold_binary
(
name
,
value
)
¶
Headers are folded using the
Header
folding algorithm, which preserves existing line breaks in the value, and wraps each resulting line to the
max_line_length
。若
cte_type
is
7bit
, non-ascii binary data is CTE encoded using the
unknown-8bit
charset. Otherwise the original source header is used, with its existing line breaks and any (RFC invalid) binary data it may contain.
脚注