Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK !
message.pynu [ # Copyright (C) 2001-2007 Python Software Foundation
# Author: Barry Warsaw
# Contact: email-sig@python.org
"""Basic message object for the email package object model."""
__all__ = ['Message', 'EmailMessage']
import re
import uu
import quopri
from io import BytesIO, StringIO
# Intrapackage imports
from email import utils
from email import errors
from email._policybase import Policy, compat32
from email import charset as _charset
from email._encoded_words import decode_b
Charset = _charset.Charset
SEMISPACE = '; '
# Regular expression that matches `special' characters in parameters, the
# existence of which force quoting of the parameter value.
tspecials = re.compile(r'[ \(\)<>@,;:\\"/\[\]\?=]')
def _splitparam(param):
# Split header parameters. BAW: this may be too simple. It isn't
# strictly RFC 2045 (section 5.1) compliant, but it catches most headers
# found in the wild. We may eventually need a full fledged parser.
# RDM: we might have a Header here; for now just stringify it.
a, sep, b = str(param).partition(';')
if not sep:
return a.strip(), None
return a.strip(), b.strip()
def _formatparam(param, value=None, quote=True):
"""Convenience function to format and return a key=value pair.
This will quote the value if needed or if quote is true. If value is a
three tuple (charset, language, value), it will be encoded according
to RFC2231 rules. If it contains non-ascii characters it will likewise
be encoded according to RFC2231 rules, using the utf-8 charset and
a null language.
"""
if value is not None and len(value) > 0:
# A tuple is used for RFC 2231 encoded parameter values where items
# are (charset, language, value). charset is a string, not a Charset
# instance. RFC 2231 encoded values are never quoted, per RFC.
if isinstance(value, tuple):
# Encode as per RFC 2231
param += '*'
value = utils.encode_rfc2231(value[2], value[0], value[1])
return '%s=%s' % (param, value)
else:
try:
value.encode('ascii')
except UnicodeEncodeError:
param += '*'
value = utils.encode_rfc2231(value, 'utf-8', '')
return '%s=%s' % (param, value)
# BAW: Please check this. I think that if quote is set it should
# force quoting even if not necessary.
if quote or tspecials.search(value):
return '%s="%s"' % (param, utils.quote(value))
else:
return '%s=%s' % (param, value)
else:
return param
def _parseparam(s):
# RDM This might be a Header, so for now stringify it.
s = ';' + str(s)
plist = []
while s[:1] == ';':
s = s[1:]
end = s.find(';')
while end > 0 and (s.count('"', 0, end) - s.count('\\"', 0, end)) % 2:
end = s.find(';', end + 1)
if end < 0:
end = len(s)
f = s[:end]
if '=' in f:
i = f.index('=')
f = f[:i].strip().lower() + '=' + f[i+1:].strip()
plist.append(f.strip())
s = s[end:]
return plist
def _unquotevalue(value):
# This is different than utils.collapse_rfc2231_value() because it doesn't
# try to convert the value to a unicode. Message.get_param() and
# Message.get_params() are both currently defined to return the tuple in
# the face of RFC 2231 parameters.
if isinstance(value, tuple):
return value[0], value[1], utils.unquote(value[2])
else:
return utils.unquote(value)
class Message:
"""Basic message object.
A message object is defined as something that has a bunch of RFC 2822
headers and a payload. It may optionally have an envelope header
(a.k.a. Unix-From or From_ header). If the message is a container (i.e. a
multipart or a message/rfc822), then the payload is a list of Message
objects, otherwise it is a string.
Message objects implement part of the `mapping' interface, which assumes
there is exactly one occurrence of the header per message. Some headers
do in fact appear multiple times (e.g. Received) and for those headers,
you must use the explicit API to set or get all the headers. Not all of
the mapping methods are implemented.
"""
def __init__(self, policy=compat32):
self.policy = policy
self._headers = []
self._unixfrom = None
self._payload = None
self._charset = None
# Defaults for multipart messages
self.preamble = self.epilogue = None
self.defects = []
# Default content type
self._default_type = 'text/plain'
def __str__(self):
"""Return the entire formatted message as a string.
"""
return self.as_string()
def as_string(self, unixfrom=False, maxheaderlen=0, policy=None):
"""Return the entire formatted message as a string.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. For backward compatibility reasons, if maxheaderlen is
not specified it defaults to 0, so you must override it explicitly
if you want a different maxheaderlen. 'policy' is passed to the
Generator instance used to serialize the message; if it is not
specified the policy associated with the message instance is used.
If the message object contains binary data that is not encoded
according to RFC standards, the non-compliant data will be replaced by
unicode "unknown character" code points.
"""
from email.generator import Generator
policy = self.policy if policy is None else policy
fp = StringIO()
g = Generator(fp,
mangle_from_=False,
maxheaderlen=maxheaderlen,
policy=policy)
g.flatten(self, unixfrom=unixfrom)
return fp.getvalue()
def __bytes__(self):
"""Return the entire formatted message as a bytes object.
"""
return self.as_bytes()
def as_bytes(self, unixfrom=False, policy=None):
"""Return the entire formatted message as a bytes object.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. 'policy' is passed to the BytesGenerator instance used to
serialize the message; if not specified the policy associated with
the message instance is used.
"""
from email.generator import BytesGenerator
policy = self.policy if policy is None else policy
fp = BytesIO()
g = BytesGenerator(fp, mangle_from_=False, policy=policy)
g.flatten(self, unixfrom=unixfrom)
return fp.getvalue()
def is_multipart(self):
"""Return True if the message consists of multiple parts."""
return isinstance(self._payload, list)
#
# Unix From_ line
#
def set_unixfrom(self, unixfrom):
self._unixfrom = unixfrom
def get_unixfrom(self):
return self._unixfrom
#
# Payload manipulation.
#
def attach(self, payload):
"""Add the given payload to the current payload.
The current payload will always be a list of objects after this method
is called. If you want to set the payload to a scalar object, use
set_payload() instead.
"""
if self._payload is None:
self._payload = [payload]
else:
try:
self._payload.append(payload)
except AttributeError:
raise TypeError("Attach is not valid on a message with a"
" non-multipart payload")
def get_payload(self, i=None, decode=False):
"""Return a reference to the payload.
The payload will either be a list object or a string. If you mutate
the list object, you modify the message's payload in place. Optional
i returns that index into the payload.
Optional decode is a flag indicating whether the payload should be
decoded or not, according to the Content-Transfer-Encoding header
(default is False).
When True and the message is not a multipart, the payload will be
decoded if this header's value is `quoted-printable' or `base64'. If
some other encoding is used, or the header is missing, or if the
payload has bogus data (i.e. bogus base64 or uuencoded data), the
payload is returned as-is.
If the message is a multipart and the decode flag is True, then None
is returned.
"""
# Here is the logic table for this code, based on the email5.0.0 code:
# i decode is_multipart result
# ------ ------ ------------ ------------------------------
# None True True None
# i True True None
# None False True _payload (a list)
# i False True _payload element i (a Message)
# i False False error (not a list)
# i True False error (not a list)
# None False False _payload
# None True False _payload decoded (bytes)
# Note that Barry planned to factor out the 'decode' case, but that
# isn't so easy now that we handle the 8 bit data, which needs to be
# converted in both the decode and non-decode path.
if self.is_multipart():
if decode:
return None
if i is None:
return self._payload
else:
return self._payload[i]
# For backward compatibility, Use isinstance and this error message
# instead of the more logical is_multipart test.
if i is not None and not isinstance(self._payload, list):
raise TypeError('Expected list, got %s' % type(self._payload))
payload = self._payload
# cte might be a Header, so for now stringify it.
cte = str(self.get('content-transfer-encoding', '')).lower()
# payload may be bytes here.
if isinstance(payload, str):
if utils._has_surrogates(payload):
bpayload = payload.encode('ascii', 'surrogateescape')
if not decode:
try:
payload = bpayload.decode(self.get_param('charset', 'ascii'), 'replace')
except LookupError:
payload = bpayload.decode('ascii', 'replace')
elif decode:
try:
bpayload = payload.encode('ascii')
except UnicodeError:
# This won't happen for RFC compliant messages (messages
# containing only ASCII code points in the unicode input).
# If it does happen, turn the string into bytes in a way
# guaranteed not to fail.
bpayload = payload.encode('raw-unicode-escape')
if not decode:
return payload
if cte == 'quoted-printable':
return quopri.decodestring(bpayload)
elif cte == 'base64':
# XXX: this is a bit of a hack; decode_b should probably be factored
# out somewhere, but I haven't figured out where yet.
value, defects = decode_b(b''.join(bpayload.splitlines()))
for defect in defects:
self.policy.handle_defect(self, defect)
return value
elif cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
in_file = BytesIO(bpayload)
out_file = BytesIO()
try:
uu.decode(in_file, out_file, quiet=True)
return out_file.getvalue()
except uu.Error:
# Some decoding problem
return bpayload
if isinstance(payload, str):
return bpayload
return payload
def set_payload(self, payload, charset=None):
"""Set the payload to the given value.
Optional charset sets the message's default character set. See
set_charset() for details.
"""
if hasattr(payload, 'encode'):
if charset is None:
self._payload = payload
return
if not isinstance(charset, Charset):
charset = Charset(charset)
payload = payload.encode(charset.output_charset)
if hasattr(payload, 'decode'):
self._payload = payload.decode('ascii', 'surrogateescape')
else:
self._payload = payload
if charset is not None:
self.set_charset(charset)
def set_charset(self, charset):
"""Set the charset of the payload to a given character set.
charset can be a Charset instance, a string naming a character set, or
None. If it is a string it will be converted to a Charset instance.
If charset is None, the charset parameter will be removed from the
Content-Type field. Anything else will generate a TypeError.
The message will be assumed to be of type text/* encoded with
charset.input_charset. It will be converted to charset.output_charset
and encoded properly, if needed, when generating the plain text
representation of the message. MIME headers (MIME-Version,
Content-Type, Content-Transfer-Encoding) will be added as needed.
"""
if charset is None:
self.del_param('charset')
self._charset = None
return
if not isinstance(charset, Charset):
charset = Charset(charset)
self._charset = charset
if 'MIME-Version' not in self:
self.add_header('MIME-Version', '1.0')
if 'Content-Type' not in self:
self.add_header('Content-Type', 'text/plain',
charset=charset.get_output_charset())
else:
self.set_param('charset', charset.get_output_charset())
if charset != charset.get_output_charset():
self._payload = charset.body_encode(self._payload)
if 'Content-Transfer-Encoding' not in self:
cte = charset.get_body_encoding()
try:
cte(self)
except TypeError:
# This 'if' is for backward compatibility, it allows unicode
# through even though that won't work correctly if the
# message is serialized.
payload = self._payload
if payload:
try:
payload = payload.encode('ascii', 'surrogateescape')
except UnicodeError:
payload = payload.encode(charset.output_charset)
self._payload = charset.body_encode(payload)
self.add_header('Content-Transfer-Encoding', cte)
def get_charset(self):
"""Return the Charset instance associated with the message's payload.
"""
return self._charset
#
# MAPPING INTERFACE (partial)
#
def __len__(self):
"""Return the total number of headers, including duplicates."""
return len(self._headers)
def __getitem__(self, name):
"""Get a header value.
Return None if the header is missing instead of raising an exception.
Note that if the header appeared multiple times, exactly which
occurrence gets returned is undefined. Use get_all() to get all
the values matching a header field name.
"""
return self.get(name)
def __setitem__(self, name, val):
"""Set the value of a header.
Note: this does not overwrite an existing header with the same field
name. Use __delitem__() first to delete any existing headers.
"""
max_count = self.policy.header_max_count(name)
if max_count:
lname = name.lower()
found = 0
for k, v in self._headers:
if k.lower() == lname:
found += 1
if found >= max_count:
raise ValueError("There may be at most {} {} headers "
"in a message".format(max_count, name))
self._headers.append(self.policy.header_store_parse(name, val))
def __delitem__(self, name):
"""Delete all occurrences of a header, if present.
Does not raise an exception if the header is missing.
"""
name = name.lower()
newheaders = []
for k, v in self._headers:
if k.lower() != name:
newheaders.append((k, v))
self._headers = newheaders
def __contains__(self, name):
return name.lower() in [k.lower() for k, v in self._headers]
def __iter__(self):
for field, value in self._headers:
yield field
def keys(self):
"""Return a list of all the message's header field names.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
return [k for k, v in self._headers]
def values(self):
"""Return a list of all the message's header values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
return [self.policy.header_fetch_parse(k, v)
for k, v in self._headers]
def items(self):
"""Get all the message's header fields and values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
return [(k, self.policy.header_fetch_parse(k, v))
for k, v in self._headers]
def get(self, name, failobj=None):
"""Get a header value.
Like __getitem__() but return failobj instead of None when the field
is missing.
"""
name = name.lower()
for k, v in self._headers:
if k.lower() == name:
return self.policy.header_fetch_parse(k, v)
return failobj
#
# "Internal" methods (public API, but only intended for use by a parser
# or generator, not normal application code.
#
def set_raw(self, name, value):
"""Store name and value in the model without modification.
This is an "internal" API, intended only for use by a parser.
"""
self._headers.append((name, value))
def raw_items(self):
"""Return the (name, value) header pairs without modification.
This is an "internal" API, intended only for use by a generator.
"""
return iter(self._headers.copy())
#
# Additional useful stuff
#
def get_all(self, name, failobj=None):
"""Return a list of all the values for the named field.
These will be sorted in the order they appeared in the original
message, and may contain duplicates. Any fields deleted and
re-inserted are always appended to the header list.
If no such fields exist, failobj is returned (defaults to None).
"""
values = []
name = name.lower()
for k, v in self._headers:
if k.lower() == name:
values.append(self.policy.header_fetch_parse(k, v))
if not values:
return failobj
return values
def add_header(self, _name, _value, **_params):
"""Extended header setting.
name is the header field to add. keyword arguments can be used to set
additional parameters for the header field, with underscores converted
to dashes. Normally the parameter will be added as key="value" unless
value is None, in which case only the key will be added. If a
parameter value contains non-ASCII characters it can be specified as a
three-tuple of (charset, language, value), in which case it will be
encoded according to RFC2231 rules. Otherwise it will be encoded using
the utf-8 charset and a language of ''.
Examples:
msg.add_header('content-disposition', 'attachment', filename='bud.gif')
msg.add_header('content-disposition', 'attachment',
filename=('utf-8', '', Fußballer.ppt'))
msg.add_header('content-disposition', 'attachment',
filename='Fußballer.ppt'))
"""
parts = []
for k, v in _params.items():
if v is None:
parts.append(k.replace('_', '-'))
else:
parts.append(_formatparam(k.replace('_', '-'), v))
if _value is not None:
parts.insert(0, _value)
self[_name] = SEMISPACE.join(parts)
def replace_header(self, _name, _value):
"""Replace a header.
Replace the first matching header found in the message, retaining
header order and case. If no matching header was found, a KeyError is
raised.
"""
_name = _name.lower()
for i, (k, v) in zip(range(len(self._headers)), self._headers):
if k.lower() == _name:
self._headers[i] = self.policy.header_store_parse(k, _value)
break
else:
raise KeyError(_name)
#
# Use these three methods instead of the three above.
#
def get_content_type(self):
"""Return the message's content type.
The returned string is coerced to lower case of the form
`maintype/subtype'. If there was no Content-Type header in the
message, the default type as given by get_default_type() will be
returned. Since according to RFC 2045, messages always have a default
type this will always return a value.
RFC 2045 defines a message's default type to be text/plain unless it
appears inside a multipart/digest container, in which case it would be
message/rfc822.
"""
missing = object()
value = self.get('content-type', missing)
if value is missing:
# This should have no parameters
return self.get_default_type()
ctype = _splitparam(value)[0].lower()
# RFC 2045, section 5.2 says if its invalid, use text/plain
if ctype.count('/') != 1:
return 'text/plain'
return ctype
def get_content_maintype(self):
"""Return the message's main content type.
This is the `maintype' part of the string returned by
get_content_type().
"""
ctype = self.get_content_type()
return ctype.split('/')[0]
def get_content_subtype(self):
"""Returns the message's sub-content type.
This is the `subtype' part of the string returned by
get_content_type().
"""
ctype = self.get_content_type()
return ctype.split('/')[1]
def get_default_type(self):
"""Return the `default' content type.
Most messages have a default content type of text/plain, except for
messages that are subparts of multipart/digest containers. Such
subparts have a default content type of message/rfc822.
"""
return self._default_type
def set_default_type(self, ctype):
"""Set the `default' content type.
ctype should be either "text/plain" or "message/rfc822", although this
is not enforced. The default content type is not stored in the
Content-Type header.
"""
self._default_type = ctype
def _get_params_preserve(self, failobj, header):
# Like get_params() but preserves the quoting of values. BAW:
# should this be part of the public interface?
missing = object()
value = self.get(header, missing)
if value is missing:
return failobj
params = []
for p in _parseparam(value):
try:
name, val = p.split('=', 1)
name = name.strip()
val = val.strip()
except ValueError:
# Must have been a bare attribute
name = p.strip()
val = ''
params.append((name, val))
params = utils.decode_params(params)
return params
def get_params(self, failobj=None, header='content-type', unquote=True):
"""Return the message's Content-Type parameters, as a list.
The elements of the returned list are 2-tuples of key/value pairs, as
split on the `=' sign. The left hand side of the `=' is the key,
while the right hand side is the value. If there is no `=' sign in
the parameter the value is the empty string. The value is as
described in the get_param() method.
Optional failobj is the object to return if there is no Content-Type
header. Optional header is the header to search instead of
Content-Type. If unquote is True, the value is unquoted.
"""
missing = object()
params = self._get_params_preserve(missing, header)
if params is missing:
return failobj
if unquote:
return [(k, _unquotevalue(v)) for k, v in params]
else:
return params
def get_param(self, param, failobj=None, header='content-type',
unquote=True):
"""Return the parameter value if found in the Content-Type header.
Optional failobj is the object to return if there is no Content-Type
header, or the Content-Type header has no such parameter. Optional
header is the header to search instead of Content-Type.
Parameter keys are always compared case insensitively. The return
value can either be a string, or a 3-tuple if the parameter was RFC
2231 encoded. When it's a 3-tuple, the elements of the value are of
the form (CHARSET, LANGUAGE, VALUE). Note that both CHARSET and
LANGUAGE can be None, in which case you should consider VALUE to be
encoded in the us-ascii charset. You can usually ignore LANGUAGE.
The parameter value (either the returned string, or the VALUE item in
the 3-tuple) is always unquoted, unless unquote is set to False.
If your application doesn't care whether the parameter was RFC 2231
encoded, it can turn the return value into a string as follows:
rawparam = msg.get_param('foo')
param = email.utils.collapse_rfc2231_value(rawparam)
"""
if header not in self:
return failobj
for k, v in self._get_params_preserve(failobj, header):
if k.lower() == param.lower():
if unquote:
return _unquotevalue(v)
else:
return v
return failobj
def set_param(self, param, value, header='Content-Type', requote=True,
charset=None, language='', replace=False):
"""Set a parameter in the Content-Type header.
If the parameter already exists in the header, its value will be
replaced with the new value.
If header is Content-Type and has not yet been defined for this
message, it will be set to "text/plain" and the new parameter and
value will be appended as per RFC 2045.
An alternate header can be specified in the header argument, and all
parameters will be quoted as necessary unless requote is False.
If charset is specified, the parameter will be encoded according to RFC
2231. Optional language specifies the RFC 2231 language, defaulting
to the empty string. Both charset and language should be strings.
"""
if not isinstance(value, tuple) and charset:
value = (charset, language, value)
if header not in self and header.lower() == 'content-type':
ctype = 'text/plain'
else:
ctype = self.get(header)
if not self.get_param(param, header=header):
if not ctype:
ctype = _formatparam(param, value, requote)
else:
ctype = SEMISPACE.join(
[ctype, _formatparam(param, value, requote)])
else:
ctype = ''
for old_param, old_value in self.get_params(header=header,
unquote=requote):
append_param = ''
if old_param.lower() == param.lower():
append_param = _formatparam(param, value, requote)
else:
append_param = _formatparam(old_param, old_value, requote)
if not ctype:
ctype = append_param
else:
ctype = SEMISPACE.join([ctype, append_param])
if ctype != self.get(header):
if replace:
self.replace_header(header, ctype)
else:
del self[header]
self[header] = ctype
def del_param(self, param, header='content-type', requote=True):
"""Remove the given parameter completely from the Content-Type header.
The header will be re-written in place without the parameter or its
value. All values will be quoted as necessary unless requote is
False. Optional header specifies an alternative to the Content-Type
header.
"""
if header not in self:
return
new_ctype = ''
for p, v in self.get_params(header=header, unquote=requote):
if p.lower() != param.lower():
if not new_ctype:
new_ctype = _formatparam(p, v, requote)
else:
new_ctype = SEMISPACE.join([new_ctype,
_formatparam(p, v, requote)])
if new_ctype != self.get(header):
del self[header]
self[header] = new_ctype
def set_type(self, type, header='Content-Type', requote=True):
"""Set the main type and subtype for the Content-Type header.
type must be a string in the form "maintype/subtype", otherwise a
ValueError is raised.
This method replaces the Content-Type header, keeping all the
parameters in place. If requote is False, this leaves the existing
header's quoting as is. Otherwise, the parameters will be quoted (the
default).
An alternative header can be specified in the header argument. When
the Content-Type header is set, we'll always also add a MIME-Version
header.
"""
# BAW: should we be strict?
if not type.count('/') == 1:
raise ValueError
# Set the Content-Type, you get a MIME-Version
if header.lower() == 'content-type':
del self['mime-version']
self['MIME-Version'] = '1.0'
if header not in self:
self[header] = type
return
params = self.get_params(header=header, unquote=requote)
del self[header]
self[header] = type
# Skip the first param; it's the old type.
for p, v in params[1:]:
self.set_param(p, v, header, requote)
def get_filename(self, failobj=None):
"""Return the filename associated with the payload if present.
The filename is extracted from the Content-Disposition header's
`filename' parameter, and it is unquoted. If that header is missing
the `filename' parameter, this method falls back to looking for the
`name' parameter.
"""
missing = object()
filename = self.get_param('filename', missing, 'content-disposition')
if filename is missing:
filename = self.get_param('name', missing, 'content-type')
if filename is missing:
return failobj
return utils.collapse_rfc2231_value(filename).strip()
def get_boundary(self, failobj=None):
"""Return the boundary associated with the payload if present.
The boundary is extracted from the Content-Type header's `boundary'
parameter, and it is unquoted.
"""
missing = object()
boundary = self.get_param('boundary', missing)
if boundary is missing:
return failobj
# RFC 2046 says that boundaries may begin but not end in w/s
return utils.collapse_rfc2231_value(boundary).rstrip()
def set_boundary(self, boundary):
"""Set the boundary parameter in Content-Type to 'boundary'.
This is subtly different than deleting the Content-Type header and
adding a new one with a new boundary parameter via add_header(). The
main difference is that using the set_boundary() method preserves the
order of the Content-Type header in the original message.
HeaderParseError is raised if the message has no Content-Type header.
"""
missing = object()
params = self._get_params_preserve(missing, 'content-type')
if params is missing:
# There was no Content-Type header, and we don't know what type
# to set it to, so raise an exception.
raise errors.HeaderParseError('No Content-Type header found')
newparams = []
foundp = False
for pk, pv in params:
if pk.lower() == 'boundary':
newparams.append(('boundary', '"%s"' % boundary))
foundp = True
else:
newparams.append((pk, pv))
if not foundp:
# The original Content-Type header had no boundary attribute.
# Tack one on the end. BAW: should we raise an exception
# instead???
newparams.append(('boundary', '"%s"' % boundary))
# Replace the existing Content-Type header with the new value
newheaders = []
for h, v in self._headers:
if h.lower() == 'content-type':
parts = []
for k, v in newparams:
if v == '':
parts.append(k)
else:
parts.append('%s=%s' % (k, v))
val = SEMISPACE.join(parts)
newheaders.append(self.policy.header_store_parse(h, val))
else:
newheaders.append((h, v))
self._headers = newheaders
def get_content_charset(self, failobj=None):
"""Return the charset parameter of the Content-Type header.
The returned string is always coerced to lower case. If there is no
Content-Type header, or if that header has no charset parameter,
failobj is returned.
"""
missing = object()
charset = self.get_param('charset', missing)
if charset is missing:
return failobj
if isinstance(charset, tuple):
# RFC 2231 encoded, so decode it, and it better end up as ascii.
pcharset = charset[0] or 'us-ascii'
try:
# LookupError will be raised if the charset isn't known to
# Python. UnicodeError will be raised if the encoded text
# contains a character not in the charset.
as_bytes = charset[2].encode('raw-unicode-escape')
charset = str(as_bytes, pcharset)
except (LookupError, UnicodeError):
charset = charset[2]
# charset characters must be in us-ascii range
try:
charset.encode('us-ascii')
except UnicodeError:
return failobj
# RFC 2046, $4.1.2 says charsets are not case sensitive
return charset.lower()
def get_charsets(self, failobj=None):
"""Return a list containing the charset(s) used in this message.
The returned list of items describes the Content-Type headers'
charset parameter for this message and all the subparts in its
payload.
Each item will either be a string (the value of the charset parameter
in the Content-Type header of that part) or the value of the
'failobj' parameter (defaults to None), if the part does not have a
main MIME type of "text", or the charset is not defined.
The list will contain one string for each part of the message, plus
one for the container message (i.e. self), so that a non-multipart
message will still return a list of length 1.
"""
return [part.get_content_charset(failobj) for part in self.walk()]
def get_content_disposition(self):
"""Return the message's content-disposition if it exists, or None.
The return values can be either 'inline', 'attachment' or None
according to the rfc2183.
"""
value = self.get('content-disposition')
if value is None:
return None
c_d = _splitparam(value)[0].lower()
return c_d
# I.e. def walk(self): ...
from email.iterators import walk
class MIMEPart(Message):
def __init__(self, policy=None):
if policy is None:
from email.policy import default
policy = default
Message.__init__(self, policy)
def as_string(self, unixfrom=False, maxheaderlen=None, policy=None):
"""Return the entire formatted message as a string.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. maxheaderlen is retained for backward compatibility with the
base Message class, but defaults to None, meaning that the policy value
for max_line_length controls the header maximum length. 'policy' is
passed to the Generator instance used to serialize the message; if it
is not specified the policy associated with the message instance is
used.
"""
policy = self.policy if policy is None else policy
if maxheaderlen is None:
maxheaderlen = policy.max_line_length
return super().as_string(maxheaderlen=maxheaderlen, policy=policy)
def __str__(self):
return self.as_string(policy=self.policy.clone(utf8=True))
def is_attachment(self):
c_d = self.get('content-disposition')
return False if c_d is None else c_d.content_disposition == 'attachment'
def _find_body(self, part, preferencelist):
if part.is_attachment():
return
maintype, subtype = part.get_content_type().split('/')
if maintype == 'text':
if subtype in preferencelist:
yield (preferencelist.index(subtype), part)
return
if maintype != 'multipart':
return
if subtype != 'related':
for subpart in part.iter_parts():
yield from self._find_body(subpart, preferencelist)
return
if 'related' in preferencelist:
yield (preferencelist.index('related'), part)
candidate = None
start = part.get_param('start')
if start:
for subpart in part.iter_parts():
if subpart['content-id'] == start:
candidate = subpart
break
if candidate is None:
subparts = part.get_payload()
candidate = subparts[0] if subparts else None
if candidate is not None:
yield from self._find_body(candidate, preferencelist)
def get_body(self, preferencelist=('related', 'html', 'plain')):
"""Return best candidate mime part for display as 'body' of message.
Do a depth first search, starting with self, looking for the first part
matching each of the items in preferencelist, and return the part
corresponding to the first item that has a match, or None if no items
have a match. If 'related' is not included in preferencelist, consider
the root part of any multipart/related encountered as a candidate
match. Ignore parts with 'Content-Disposition: attachment'.
"""
best_prio = len(preferencelist)
body = None
for prio, part in self._find_body(self, preferencelist):
if prio < best_prio:
best_prio = prio
body = part
if prio == 0:
break
return body
_body_types = {('text', 'plain'),
('text', 'html'),
('multipart', 'related'),
('multipart', 'alternative')}
def iter_attachments(self):
"""Return an iterator over the non-main parts of a multipart.
Skip the first of each occurrence of text/plain, text/html,
multipart/related, or multipart/alternative in the multipart (unless
they have a 'Content-Disposition: attachment' header) and include all
remaining subparts in the returned iterator. When applied to a
multipart/related, return all parts except the root part. Return an
empty iterator when applied to a multipart/alternative or a
non-multipart.
"""
maintype, subtype = self.get_content_type().split('/')
if maintype != 'multipart' or subtype == 'alternative':
return
payload = self.get_payload()
# Certain malformed messages can have content type set to `multipart/*`
# but still have single part body, in which case payload.copy() can
# fail with AttributeError.
try:
parts = payload.copy()
except AttributeError:
# payload is not a list, it is most probably a string.
return
if maintype == 'multipart' and subtype == 'related':
# For related, we treat everything but the root as an attachment.
# The root may be indicated by 'start'; if there's no start or we
# can't find the named start, treat the first subpart as the root.
start = self.get_param('start')
if start:
found = False
attachments = []
for part in parts:
if part.get('content-id') == start:
found = True
else:
attachments.append(part)
if found:
yield from attachments
return
parts.pop(0)
yield from parts
return
# Otherwise we more or less invert the remaining logic in get_body.
# This only really works in edge cases (ex: non-text related or
# alternatives) if the sending agent sets content-disposition.
seen = [] # Only skip the first example of each candidate type.
for part in parts:
maintype, subtype = part.get_content_type().split('/')
if ((maintype, subtype) in self._body_types and
not part.is_attachment() and subtype not in seen):
seen.append(subtype)
continue
yield part
def iter_parts(self):
"""Return an iterator over all immediate subparts of a multipart.
Return an empty iterator for a non-multipart.
"""
if self.get_content_maintype() == 'multipart':
yield from self.get_payload()
def get_content(self, *args, content_manager=None, **kw):
if content_manager is None:
content_manager = self.policy.content_manager
return content_manager.get_content(self, *args, **kw)
def set_content(self, *args, content_manager=None, **kw):
if content_manager is None:
content_manager = self.policy.content_manager
content_manager.set_content(self, *args, **kw)
def _make_multipart(self, subtype, disallowed_subtypes, boundary):
if self.get_content_maintype() == 'multipart':
existing_subtype = self.get_content_subtype()
disallowed_subtypes = disallowed_subtypes + (subtype,)
if existing_subtype in disallowed_subtypes:
raise ValueError("Cannot convert {} to {}".format(
existing_subtype, subtype))
keep_headers = []
part_headers = []
for name, value in self._headers:
if name.lower().startswith('content-'):
part_headers.append((name, value))
else:
keep_headers.append((name, value))
if part_headers:
# There is existing content, move it to the first subpart.
part = type(self)(policy=self.policy)
part._headers = part_headers
part._payload = self._payload
self._payload = [part]
else:
self._payload = []
self._headers = keep_headers
self['Content-Type'] = 'multipart/' + subtype
if boundary is not None:
self.set_param('boundary', boundary)
def make_related(self, boundary=None):
self._make_multipart('related', ('alternative', 'mixed'), boundary)
def make_alternative(self, boundary=None):
self._make_multipart('alternative', ('mixed',), boundary)
def make_mixed(self, boundary=None):
self._make_multipart('mixed', (), boundary)
def _add_multipart(self, _subtype, *args, _disp=None, **kw):
if (self.get_content_maintype() != 'multipart' or
self.get_content_subtype() != _subtype):
getattr(self, 'make_' + _subtype)()
part = type(self)(policy=self.policy)
part.set_content(*args, **kw)
if _disp and 'content-disposition' not in part:
part['Content-Disposition'] = _disp
self.attach(part)
def add_related(self, *args, **kw):
self._add_multipart('related', *args, _disp='inline', **kw)
def add_alternative(self, *args, **kw):
self._add_multipart('alternative', *args, **kw)
def add_attachment(self, *args, **kw):
self._add_multipart('mixed', *args, _disp='attachment', **kw)
def clear(self):
self._headers = []
self._payload = None
def clear_content(self):
self._headers = [(n, v) for n, v in self._headers
if not n.lower().startswith('content-')]
self._payload = None
class EmailMessage(MIMEPart):
def set_content(self, *args, **kw):
super().set_content(*args, **kw)
if 'MIME-Version' not in self:
self['MIME-Version'] = '1.0'
PK ! z- __init__.pynu [ # Copyright (C) 2001-2007 Python Software Foundation
# Author: Barry Warsaw
# Contact: email-sig@python.org
"""A package for parsing, handling, and generating email messages."""
__all__ = [
'base64mime',
'charset',
'encoders',
'errors',
'feedparser',
'generator',
'header',
'iterators',
'message',
'message_from_file',
'message_from_binary_file',
'message_from_string',
'message_from_bytes',
'mime',
'parser',
'quoprimime',
'utils',
]
# Some convenience routines. Don't import Parser and Message as side-effects
# of importing email since those cascadingly import most of the rest of the
# email package.
def message_from_string(s, *args, **kws):
"""Parse a string into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from email.parser import Parser
return Parser(*args, **kws).parsestr(s)
def message_from_bytes(s, *args, **kws):
"""Parse a bytes string into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from email.parser import BytesParser
return BytesParser(*args, **kws).parsebytes(s)
def message_from_file(fp, *args, **kws):
"""Read a file and parse its contents into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from email.parser import Parser
return Parser(*args, **kws).parse(fp)
def message_from_binary_file(fp, *args, **kws):
"""Read a binary file and parse its contents into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from email.parser import BytesParser
return BytesParser(*args, **kws).parse(fp)
PK ! fKQ KQ headerregistry.pynu [ """Representing and manipulating email headers via custom objects.
This module provides an implementation of the HeaderRegistry API.
The implementation is designed to flexibly follow RFC5322 rules.
Eventually HeaderRegistry will be a public API, but it isn't yet,
and will probably change some before that happens.
"""
from types import MappingProxyType
from email import utils
from email import errors
from email import _header_value_parser as parser
class Address:
def __init__(self, display_name='', username='', domain='', addr_spec=None):
"""Create an object representing a full email address.
An address can have a 'display_name', a 'username', and a 'domain'. In
addition to specifying the username and domain separately, they may be
specified together by using the addr_spec keyword *instead of* the
username and domain keywords. If an addr_spec string is specified it
must be properly quoted according to RFC 5322 rules; an error will be
raised if it is not.
An Address object has display_name, username, domain, and addr_spec
attributes, all of which are read-only. The addr_spec and the string
value of the object are both quoted according to RFC5322 rules, but
without any Content Transfer Encoding.
"""
inputs = ''.join(filter(None, (display_name, username, domain, addr_spec)))
if '\r' in inputs or '\n' in inputs:
raise ValueError("invalid arguments; address parts cannot contain CR or LF")
# This clause with its potential 'raise' may only happen when an
# application program creates an Address object using an addr_spec
# keyword. The email library code itself must always supply username
# and domain.
if addr_spec is not None:
if username or domain:
raise TypeError("addrspec specified when username and/or "
"domain also specified")
a_s, rest = parser.get_addr_spec(addr_spec)
if rest:
raise ValueError("Invalid addr_spec; only '{}' "
"could be parsed from '{}'".format(
a_s, addr_spec))
if a_s.all_defects:
raise a_s.all_defects[0]
username = a_s.local_part
domain = a_s.domain
self._display_name = display_name
self._username = username
self._domain = domain
@property
def display_name(self):
return self._display_name
@property
def username(self):
return self._username
@property
def domain(self):
return self._domain
@property
def addr_spec(self):
"""The addr_spec (username@domain) portion of the address, quoted
according to RFC 5322 rules, but with no Content Transfer Encoding.
"""
nameset = set(self.username)
if len(nameset) > len(nameset-parser.DOT_ATOM_ENDS):
lp = parser.quote_string(self.username)
else:
lp = self.username
if self.domain:
return lp + '@' + self.domain
if not lp:
return '<>'
return lp
def __repr__(self):
return "{}(display_name={!r}, username={!r}, domain={!r})".format(
self.__class__.__name__,
self.display_name, self.username, self.domain)
def __str__(self):
nameset = set(self.display_name)
if len(nameset) > len(nameset-parser.SPECIALS):
disp = parser.quote_string(self.display_name)
else:
disp = self.display_name
if disp:
addr_spec = '' if self.addr_spec=='<>' else self.addr_spec
return "{} <{}>".format(disp, addr_spec)
return self.addr_spec
def __eq__(self, other):
if type(other) != type(self):
return False
return (self.display_name == other.display_name and
self.username == other.username and
self.domain == other.domain)
class Group:
def __init__(self, display_name=None, addresses=None):
"""Create an object representing an address group.
An address group consists of a display_name followed by colon and a
list of addresses (see Address) terminated by a semi-colon. The Group
is created by specifying a display_name and a possibly empty list of
Address objects. A Group can also be used to represent a single
address that is not in a group, which is convenient when manipulating
lists that are a combination of Groups and individual Addresses. In
this case the display_name should be set to None. In particular, the
string representation of a Group whose display_name is None is the same
as the Address object, if there is one and only one Address object in
the addresses list.
"""
self._display_name = display_name
self._addresses = tuple(addresses) if addresses else tuple()
@property
def display_name(self):
return self._display_name
@property
def addresses(self):
return self._addresses
def __repr__(self):
return "{}(display_name={!r}, addresses={!r}".format(
self.__class__.__name__,
self.display_name, self.addresses)
def __str__(self):
if self.display_name is None and len(self.addresses)==1:
return str(self.addresses[0])
disp = self.display_name
if disp is not None:
nameset = set(disp)
if len(nameset) > len(nameset-parser.SPECIALS):
disp = parser.quote_string(disp)
adrstr = ", ".join(str(x) for x in self.addresses)
adrstr = ' ' + adrstr if adrstr else adrstr
return "{}:{};".format(disp, adrstr)
def __eq__(self, other):
if type(other) != type(self):
return False
return (self.display_name == other.display_name and
self.addresses == other.addresses)
# Header Classes #
class BaseHeader(str):
"""Base class for message headers.
Implements generic behavior and provides tools for subclasses.
A subclass must define a classmethod named 'parse' that takes an unfolded
value string and a dictionary as its arguments. The dictionary will
contain one key, 'defects', initialized to an empty list. After the call
the dictionary must contain two additional keys: parse_tree, set to the
parse tree obtained from parsing the header, and 'decoded', set to the
string value of the idealized representation of the data from the value.
(That is, encoded words are decoded, and values that have canonical
representations are so represented.)
The defects key is intended to collect parsing defects, which the message
parser will subsequently dispose of as appropriate. The parser should not,
insofar as practical, raise any errors. Defects should be added to the
list instead. The standard header parsers register defects for RFC
compliance issues, for obsolete RFC syntax, and for unrecoverable parsing
errors.
The parse method may add additional keys to the dictionary. In this case
the subclass must define an 'init' method, which will be passed the
dictionary as its keyword arguments. The method should use (usually by
setting them as the value of similarly named attributes) and remove all the
extra keys added by its parse method, and then use super to call its parent
class with the remaining arguments and keywords.
The subclass should also make sure that a 'max_count' attribute is defined
that is either None or 1. XXX: need to better define this API.
"""
def __new__(cls, name, value):
kwds = {'defects': []}
cls.parse(value, kwds)
if utils._has_surrogates(kwds['decoded']):
kwds['decoded'] = utils._sanitize(kwds['decoded'])
self = str.__new__(cls, kwds['decoded'])
del kwds['decoded']
self.init(name, **kwds)
return self
def init(self, name, *, parse_tree, defects):
self._name = name
self._parse_tree = parse_tree
self._defects = defects
@property
def name(self):
return self._name
@property
def defects(self):
return tuple(self._defects)
def __reduce__(self):
return (
_reconstruct_header,
(
self.__class__.__name__,
self.__class__.__bases__,
str(self),
),
self.__dict__)
@classmethod
def _reconstruct(cls, value):
return str.__new__(cls, value)
def fold(self, *, policy):
"""Fold header according to policy.
The parsed representation of the header is folded according to
RFC5322 rules, as modified by the policy. If the parse tree
contains surrogateescaped bytes, the bytes are CTE encoded using
the charset 'unknown-8bit".
Any non-ASCII characters in the parse tree are CTE encoded using
charset utf-8. XXX: make this a policy setting.
The returned value is an ASCII-only string possibly containing linesep
characters, and ending with a linesep character. The string includes
the header name and the ': ' separator.
"""
# At some point we need to put fws here if it was in the source.
header = parser.Header([
parser.HeaderLabel([
parser.ValueTerminal(self.name, 'header-name'),
parser.ValueTerminal(':', 'header-sep')]),
])
if self._parse_tree:
header.append(
parser.CFWSList([parser.WhiteSpaceTerminal(' ', 'fws')]))
header.append(self._parse_tree)
return header.fold(policy=policy)
def _reconstruct_header(cls_name, bases, value):
return type(cls_name, bases, {})._reconstruct(value)
class UnstructuredHeader:
max_count = None
value_parser = staticmethod(parser.get_unstructured)
@classmethod
def parse(cls, value, kwds):
kwds['parse_tree'] = cls.value_parser(value)
kwds['decoded'] = str(kwds['parse_tree'])
class UniqueUnstructuredHeader(UnstructuredHeader):
max_count = 1
class DateHeader:
"""Header whose value consists of a single timestamp.
Provides an additional attribute, datetime, which is either an aware
datetime using a timezone, or a naive datetime if the timezone
in the input string is -0000. Also accepts a datetime as input.
The 'value' attribute is the normalized form of the timestamp,
which means it is the output of format_datetime on the datetime.
"""
max_count = None
# This is used only for folding, not for creating 'decoded'.
value_parser = staticmethod(parser.get_unstructured)
@classmethod
def parse(cls, value, kwds):
if not value:
kwds['defects'].append(errors.HeaderMissingRequiredValue())
kwds['datetime'] = None
kwds['decoded'] = ''
kwds['parse_tree'] = parser.TokenList()
return
if isinstance(value, str):
value = utils.parsedate_to_datetime(value)
kwds['datetime'] = value
kwds['decoded'] = utils.format_datetime(kwds['datetime'])
kwds['parse_tree'] = cls.value_parser(kwds['decoded'])
def init(self, *args, **kw):
self._datetime = kw.pop('datetime')
super().init(*args, **kw)
@property
def datetime(self):
return self._datetime
class UniqueDateHeader(DateHeader):
max_count = 1
class AddressHeader:
max_count = None
@staticmethod
def value_parser(value):
address_list, value = parser.get_address_list(value)
assert not value, 'this should not happen'
return address_list
@classmethod
def parse(cls, value, kwds):
if isinstance(value, str):
# We are translating here from the RFC language (address/mailbox)
# to our API language (group/address).
kwds['parse_tree'] = address_list = cls.value_parser(value)
groups = []
for addr in address_list.addresses:
groups.append(Group(addr.display_name,
[Address(mb.display_name or '',
mb.local_part or '',
mb.domain or '')
for mb in addr.all_mailboxes]))
defects = list(address_list.all_defects)
else:
# Assume it is Address/Group stuff
if not hasattr(value, '__iter__'):
value = [value]
groups = [Group(None, [item]) if not hasattr(item, 'addresses')
else item
for item in value]
defects = []
kwds['groups'] = groups
kwds['defects'] = defects
kwds['decoded'] = ', '.join([str(item) for item in groups])
if 'parse_tree' not in kwds:
kwds['parse_tree'] = cls.value_parser(kwds['decoded'])
def init(self, *args, **kw):
self._groups = tuple(kw.pop('groups'))
self._addresses = None
super().init(*args, **kw)
@property
def groups(self):
return self._groups
@property
def addresses(self):
if self._addresses is None:
self._addresses = tuple(address for group in self._groups
for address in group.addresses)
return self._addresses
class UniqueAddressHeader(AddressHeader):
max_count = 1
class SingleAddressHeader(AddressHeader):
@property
def address(self):
if len(self.addresses)!=1:
raise ValueError(("value of single address header {} is not "
"a single address").format(self.name))
return self.addresses[0]
class UniqueSingleAddressHeader(SingleAddressHeader):
max_count = 1
class MIMEVersionHeader:
max_count = 1
value_parser = staticmethod(parser.parse_mime_version)
@classmethod
def parse(cls, value, kwds):
kwds['parse_tree'] = parse_tree = cls.value_parser(value)
kwds['decoded'] = str(parse_tree)
kwds['defects'].extend(parse_tree.all_defects)
kwds['major'] = None if parse_tree.minor is None else parse_tree.major
kwds['minor'] = parse_tree.minor
if parse_tree.minor is not None:
kwds['version'] = '{}.{}'.format(kwds['major'], kwds['minor'])
else:
kwds['version'] = None
def init(self, *args, **kw):
self._version = kw.pop('version')
self._major = kw.pop('major')
self._minor = kw.pop('minor')
super().init(*args, **kw)
@property
def major(self):
return self._major
@property
def minor(self):
return self._minor
@property
def version(self):
return self._version
class ParameterizedMIMEHeader:
# Mixin that handles the params dict. Must be subclassed and
# a property value_parser for the specific header provided.
max_count = 1
@classmethod
def parse(cls, value, kwds):
kwds['parse_tree'] = parse_tree = cls.value_parser(value)
kwds['decoded'] = str(parse_tree)
kwds['defects'].extend(parse_tree.all_defects)
if parse_tree.params is None:
kwds['params'] = {}
else:
# The MIME RFCs specify that parameter ordering is arbitrary.
kwds['params'] = {utils._sanitize(name).lower():
utils._sanitize(value)
for name, value in parse_tree.params}
def init(self, *args, **kw):
self._params = kw.pop('params')
super().init(*args, **kw)
@property
def params(self):
return MappingProxyType(self._params)
class ContentTypeHeader(ParameterizedMIMEHeader):
value_parser = staticmethod(parser.parse_content_type_header)
def init(self, *args, **kw):
super().init(*args, **kw)
self._maintype = utils._sanitize(self._parse_tree.maintype)
self._subtype = utils._sanitize(self._parse_tree.subtype)
@property
def maintype(self):
return self._maintype
@property
def subtype(self):
return self._subtype
@property
def content_type(self):
return self.maintype + '/' + self.subtype
class ContentDispositionHeader(ParameterizedMIMEHeader):
value_parser = staticmethod(parser.parse_content_disposition_header)
def init(self, *args, **kw):
super().init(*args, **kw)
cd = self._parse_tree.content_disposition
self._content_disposition = cd if cd is None else utils._sanitize(cd)
@property
def content_disposition(self):
return self._content_disposition
class ContentTransferEncodingHeader:
max_count = 1
value_parser = staticmethod(parser.parse_content_transfer_encoding_header)
@classmethod
def parse(cls, value, kwds):
kwds['parse_tree'] = parse_tree = cls.value_parser(value)
kwds['decoded'] = str(parse_tree)
kwds['defects'].extend(parse_tree.all_defects)
def init(self, *args, **kw):
super().init(*args, **kw)
self._cte = utils._sanitize(self._parse_tree.cte)
@property
def cte(self):
return self._cte
class MessageIDHeader:
max_count = 1
value_parser = staticmethod(parser.parse_message_id)
@classmethod
def parse(cls, value, kwds):
kwds['parse_tree'] = parse_tree = cls.value_parser(value)
kwds['decoded'] = str(parse_tree)
kwds['defects'].extend(parse_tree.all_defects)
# The header factory #
_default_header_map = {
'subject': UniqueUnstructuredHeader,
'date': UniqueDateHeader,
'resent-date': DateHeader,
'orig-date': UniqueDateHeader,
'sender': UniqueSingleAddressHeader,
'resent-sender': SingleAddressHeader,
'to': UniqueAddressHeader,
'resent-to': AddressHeader,
'cc': UniqueAddressHeader,
'resent-cc': AddressHeader,
'bcc': UniqueAddressHeader,
'resent-bcc': AddressHeader,
'from': UniqueAddressHeader,
'resent-from': AddressHeader,
'reply-to': UniqueAddressHeader,
'mime-version': MIMEVersionHeader,
'content-type': ContentTypeHeader,
'content-disposition': ContentDispositionHeader,
'content-transfer-encoding': ContentTransferEncodingHeader,
'message-id': MessageIDHeader,
}
class HeaderRegistry:
"""A header_factory and header registry."""
def __init__(self, base_class=BaseHeader, default_class=UnstructuredHeader,
use_default_map=True):
"""Create a header_factory that works with the Policy API.
base_class is the class that will be the last class in the created
header class's __bases__ list. default_class is the class that will be
used if "name" (see __call__) does not appear in the registry.
use_default_map controls whether or not the default mapping of names to
specialized classes is copied in to the registry when the factory is
created. The default is True.
"""
self.registry = {}
self.base_class = base_class
self.default_class = default_class
if use_default_map:
self.registry.update(_default_header_map)
def map_to_type(self, name, cls):
"""Register cls as the specialized class for handling "name" headers.
"""
self.registry[name.lower()] = cls
def __getitem__(self, name):
cls = self.registry.get(name.lower(), self.default_class)
return type('_'+cls.__name__, (cls, self.base_class), {})
def __call__(self, name, value):
"""Create a header instance for header 'name' from 'value'.
Creates a header instance by creating a specialized class for parsing
and representing the specified header by combining the factory
base_class with a specialized class from the registry or the
default_class, and passing the name and value to the constructed
class's constructor.
"""
return self[name](name, value)
PK ! maxlen:
# This last character doesn't fit so pop it off.
current_line.pop()
# Does nothing fit on the first line?
if not lines and not current_line:
lines.append(None)
else:
separator = (' ' if lines else '')
joined_line = EMPTYSTRING.join(current_line)
header_bytes = _encode(joined_line, codec)
lines.append(encoder(header_bytes))
current_line = [character]
maxlen = next(maxlengths) - extra
joined_line = EMPTYSTRING.join(current_line)
header_bytes = _encode(joined_line, codec)
lines.append(encoder(header_bytes))
return lines
def _get_encoder(self, header_bytes):
if self.header_encoding == BASE64:
return email.base64mime
elif self.header_encoding == QP:
return email.quoprimime
elif self.header_encoding == SHORTEST:
len64 = email.base64mime.header_length(header_bytes)
lenqp = email.quoprimime.header_length(header_bytes)
if len64 < lenqp:
return email.base64mime
else:
return email.quoprimime
else:
return None
def body_encode(self, string):
"""Body-encode a string by converting it first to bytes.
The type of encoding (base64 or quoted-printable) will be based on
self.body_encoding. If body_encoding is None, we assume the
output charset is a 7bit encoding, so re-encoding the decoded
string using the ascii codec produces the correct string version
of the content.
"""
if not string:
return string
if self.body_encoding is BASE64:
if isinstance(string, str):
string = string.encode(self.output_charset)
return email.base64mime.body_encode(string)
elif self.body_encoding is QP:
# quopromime.body_encode takes a string, but operates on it as if
# it were a list of byte codes. For a (minimal) history on why
# this is so, see changeset 0cf700464177. To correctly encode a
# character set, then, we must turn it into pseudo bytes via the
# latin1 charset, which will encode any byte as a single code point
# between 0 and 255, which is what body_encode is expecting.
if isinstance(string, str):
string = string.encode(self.output_charset)
string = string.decode('latin1')
return email.quoprimime.body_encode(string)
else:
if isinstance(string, str):
string = string.encode(self.output_charset).decode('ascii')
return string
PK ! 54W W iterators.pynu [ # Copyright (C) 2001-2006 Python Software Foundation
# Author: Barry Warsaw
# Contact: email-sig@python.org
"""Various types of useful iterators and generators."""
__all__ = [
'body_line_iterator',
'typed_subpart_iterator',
'walk',
# Do not include _structure() since it's part of the debugging API.
]
import sys
from io import StringIO
# This function will become a method of the Message class
def walk(self):
"""Walk over the message tree, yielding each subpart.
The walk is performed in depth-first order. This method is a
generator.
"""
yield self
if self.is_multipart():
for subpart in self.get_payload():
yield from subpart.walk()
# These two functions are imported into the Iterators.py interface module.
def body_line_iterator(msg, decode=False):
"""Iterate over the parts, returning string payloads line-by-line.
Optional decode (default False) is passed through to .get_payload().
"""
for subpart in msg.walk():
payload = subpart.get_payload(decode=decode)
if isinstance(payload, str):
yield from StringIO(payload)
def typed_subpart_iterator(msg, maintype='text', subtype=None):
"""Iterate over the subparts with a given MIME type.
Use `maintype' as the main MIME type to match against; this defaults to
"text". Optional `subtype' is the MIME subtype to match against; if
omitted, only the main type is matched.
"""
for subpart in msg.walk():
if subpart.get_content_maintype() == maintype:
if subtype is None or subpart.get_content_subtype() == subtype:
yield subpart
def _structure(msg, fp=None, level=0, include_default=False):
"""A handy debugging aid"""
if fp is None:
fp = sys.stdout
tab = ' ' * (level * 4)
print(tab + msg.get_content_type(), end='', file=fp)
if include_default:
print(' [%s]' % msg.get_default_type(), file=fp)
else:
print(file=fp)
if msg.is_multipart():
for subpart in msg.get_payload():
_structure(subpart, fp, level+1, include_default)
PK ! E E
_parseaddr.pynu [ # Copyright (C) 2002-2007 Python Software Foundation
# Contact: email-sig@python.org
"""Email address parsing code.
Lifted directly from rfc822.py. This should eventually be rewritten.
"""
__all__ = [
'mktime_tz',
'parsedate',
'parsedate_tz',
'quote',
]
import time, calendar
SPACE = ' '
EMPTYSTRING = ''
COMMASPACE = ', '
# Parse a date field
_monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul',
'aug', 'sep', 'oct', 'nov', 'dec',
'january', 'february', 'march', 'april', 'may', 'june', 'july',
'august', 'september', 'october', 'november', 'december']
_daynames = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']
# The timezone table does not include the military time zones defined
# in RFC822, other than Z. According to RFC1123, the description in
# RFC822 gets the signs wrong, so we can't rely on any such time
# zones. RFC1123 recommends that numeric timezone indicators be used
# instead of timezone names.
_timezones = {'UT':0, 'UTC':0, 'GMT':0, 'Z':0,
'AST': -400, 'ADT': -300, # Atlantic (used in Canada)
'EST': -500, 'EDT': -400, # Eastern
'CST': -600, 'CDT': -500, # Central
'MST': -700, 'MDT': -600, # Mountain
'PST': -800, 'PDT': -700 # Pacific
}
def parsedate_tz(data):
"""Convert a date string to a time tuple.
Accounts for military timezones.
"""
res = _parsedate_tz(data)
if not res:
return
if res[9] is None:
res[9] = 0
return tuple(res)
def _parsedate_tz(data):
"""Convert date to extended time tuple.
The last (additional) element is the time zone offset in seconds, except if
the timezone was specified as -0000. In that case the last element is
None. This indicates a UTC timestamp that explicitly declaims knowledge of
the source timezone, as opposed to a +0000 timestamp that indicates the
source timezone really was UTC.
"""
if not data:
return
data = data.split()
if not data: # This happens for whitespace-only input.
return None
# The FWS after the comma after the day-of-week is optional, so search and
# adjust for this.
if data[0].endswith(',') or data[0].lower() in _daynames:
# There's a dayname here. Skip it
del data[0]
else:
i = data[0].rfind(',')
if i >= 0:
data[0] = data[0][i+1:]
if len(data) == 3: # RFC 850 date, deprecated
stuff = data[0].split('-')
if len(stuff) == 3:
data = stuff + data[1:]
if len(data) == 4:
s = data[3]
i = s.find('+')
if i == -1:
i = s.find('-')
if i > 0:
data[3:] = [s[:i], s[i:]]
else:
data.append('') # Dummy tz
if len(data) < 5:
return None
data = data[:5]
[dd, mm, yy, tm, tz] = data
mm = mm.lower()
if mm not in _monthnames:
dd, mm = mm, dd.lower()
if mm not in _monthnames:
return None
mm = _monthnames.index(mm) + 1
if mm > 12:
mm -= 12
if dd[-1] == ',':
dd = dd[:-1]
i = yy.find(':')
if i > 0:
yy, tm = tm, yy
if yy[-1] == ',':
yy = yy[:-1]
if not yy[0].isdigit():
yy, tz = tz, yy
if tm[-1] == ',':
tm = tm[:-1]
tm = tm.split(':')
if len(tm) == 2:
[thh, tmm] = tm
tss = '0'
elif len(tm) == 3:
[thh, tmm, tss] = tm
elif len(tm) == 1 and '.' in tm[0]:
# Some non-compliant MUAs use '.' to separate time elements.
tm = tm[0].split('.')
if len(tm) == 2:
[thh, tmm] = tm
tss = 0
elif len(tm) == 3:
[thh, tmm, tss] = tm
else:
return None
try:
yy = int(yy)
dd = int(dd)
thh = int(thh)
tmm = int(tmm)
tss = int(tss)
except ValueError:
return None
# Check for a yy specified in two-digit format, then convert it to the
# appropriate four-digit format, according to the POSIX standard. RFC 822
# calls for a two-digit yy, but RFC 2822 (which obsoletes RFC 822)
# mandates a 4-digit yy. For more information, see the documentation for
# the time module.
if yy < 100:
# The year is between 1969 and 1999 (inclusive).
if yy > 68:
yy += 1900
# The year is between 2000 and 2068 (inclusive).
else:
yy += 2000
tzoffset = None
tz = tz.upper()
if tz in _timezones:
tzoffset = _timezones[tz]
else:
try:
tzoffset = int(tz)
except ValueError:
pass
if tzoffset==0 and tz.startswith('-'):
tzoffset = None
# Convert a timezone offset into seconds ; -0500 -> -18000
if tzoffset:
if tzoffset < 0:
tzsign = -1
tzoffset = -tzoffset
else:
tzsign = 1
tzoffset = tzsign * ( (tzoffset//100)*3600 + (tzoffset % 100)*60)
# Daylight Saving Time flag is set to -1, since DST is unknown.
return [yy, mm, dd, thh, tmm, tss, 0, 1, -1, tzoffset]
def parsedate(data):
"""Convert a time string to a time tuple."""
t = parsedate_tz(data)
if isinstance(t, tuple):
return t[:9]
else:
return t
def mktime_tz(data):
"""Turn a 10-tuple as returned by parsedate_tz() into a POSIX timestamp."""
if data[9] is None:
# No zone info, so localtime is better assumption than GMT
return time.mktime(data[:8] + (-1,))
else:
t = calendar.timegm(data)
return t - data[9]
def quote(str):
"""Prepare string to be used in a quoted string.
Turns backslash and double quote characters into quoted pairs. These
are the only characters that need to be quoted inside a quoted string.
Does not add the surrounding double quotes.
"""
return str.replace('\\', '\\\\').replace('"', '\\"')
class AddrlistClass:
"""Address parser class by Ben Escoto.
To understand what this class does, it helps to have a copy of RFC 2822 in
front of you.
Note: this class interface is deprecated and may be removed in the future.
Use email.utils.AddressList instead.
"""
def __init__(self, field):
"""Initialize a new instance.
`field' is an unparsed address header field, containing
one or more addresses.
"""
self.specials = '()<>@,:;.\"[]'
self.pos = 0
self.LWS = ' \t'
self.CR = '\r\n'
self.FWS = self.LWS + self.CR
self.atomends = self.specials + self.LWS + self.CR
# Note that RFC 2822 now specifies `.' as obs-phrase, meaning that it
# is obsolete syntax. RFC 2822 requires that we recognize obsolete
# syntax, so allow dots in phrases.
self.phraseends = self.atomends.replace('.', '')
self.field = field
self.commentlist = []
def gotonext(self):
"""Skip white space and extract comments."""
wslist = []
while self.pos < len(self.field):
if self.field[self.pos] in self.LWS + '\n\r':
if self.field[self.pos] not in '\n\r':
wslist.append(self.field[self.pos])
self.pos += 1
elif self.field[self.pos] == '(':
self.commentlist.append(self.getcomment())
else:
break
return EMPTYSTRING.join(wslist)
def getaddrlist(self):
"""Parse all addresses.
Returns a list containing all of the addresses.
"""
result = []
while self.pos < len(self.field):
ad = self.getaddress()
if ad:
result += ad
else:
result.append(('', ''))
return result
def getaddress(self):
"""Parse the next address."""
self.commentlist = []
self.gotonext()
oldpos = self.pos
oldcl = self.commentlist
plist = self.getphraselist()
self.gotonext()
returnlist = []
if self.pos >= len(self.field):
# Bad email address technically, no domain.
if plist:
returnlist = [(SPACE.join(self.commentlist), plist[0])]
elif self.field[self.pos] in '.@':
# email address is just an addrspec
# this isn't very efficient since we start over
self.pos = oldpos
self.commentlist = oldcl
addrspec = self.getaddrspec()
returnlist = [(SPACE.join(self.commentlist), addrspec)]
elif self.field[self.pos] == ':':
# address is a group
returnlist = []
fieldlen = len(self.field)
self.pos += 1
while self.pos < len(self.field):
self.gotonext()
if self.pos < fieldlen and self.field[self.pos] == ';':
self.pos += 1
break
returnlist = returnlist + self.getaddress()
elif self.field[self.pos] == '<':
# Address is a phrase then a route addr
routeaddr = self.getrouteaddr()
if self.commentlist:
returnlist = [(SPACE.join(plist) + ' (' +
' '.join(self.commentlist) + ')', routeaddr)]
else:
returnlist = [(SPACE.join(plist), routeaddr)]
else:
if plist:
returnlist = [(SPACE.join(self.commentlist), plist[0])]
elif self.field[self.pos] in self.specials:
self.pos += 1
self.gotonext()
if self.pos < len(self.field) and self.field[self.pos] == ',':
self.pos += 1
return returnlist
def getrouteaddr(self):
"""Parse a route address (Return-path value).
This method just skips all the route stuff and returns the addrspec.
"""
if self.field[self.pos] != '<':
return
expectroute = False
self.pos += 1
self.gotonext()
adlist = ''
while self.pos < len(self.field):
if expectroute:
self.getdomain()
expectroute = False
elif self.field[self.pos] == '>':
self.pos += 1
break
elif self.field[self.pos] == '@':
self.pos += 1
expectroute = True
elif self.field[self.pos] == ':':
self.pos += 1
else:
adlist = self.getaddrspec()
self.pos += 1
break
self.gotonext()
return adlist
def getaddrspec(self):
"""Parse an RFC 2822 addr-spec."""
aslist = []
self.gotonext()
while self.pos < len(self.field):
preserve_ws = True
if self.field[self.pos] == '.':
if aslist and not aslist[-1].strip():
aslist.pop()
aslist.append('.')
self.pos += 1
preserve_ws = False
elif self.field[self.pos] == '"':
aslist.append('"%s"' % quote(self.getquote()))
elif self.field[self.pos] in self.atomends:
if aslist and not aslist[-1].strip():
aslist.pop()
break
else:
aslist.append(self.getatom())
ws = self.gotonext()
if preserve_ws and ws:
aslist.append(ws)
if self.pos >= len(self.field) or self.field[self.pos] != '@':
return EMPTYSTRING.join(aslist)
aslist.append('@')
self.pos += 1
self.gotonext()
domain = self.getdomain()
if not domain:
# Invalid domain, return an empty address instead of returning a
# local part to denote failed parsing.
return EMPTYSTRING
return EMPTYSTRING.join(aslist) + domain
def getdomain(self):
"""Get the complete domain name from an address."""
sdlist = []
while self.pos < len(self.field):
if self.field[self.pos] in self.LWS:
self.pos += 1
elif self.field[self.pos] == '(':
self.commentlist.append(self.getcomment())
elif self.field[self.pos] == '[':
sdlist.append(self.getdomainliteral())
elif self.field[self.pos] == '.':
self.pos += 1
sdlist.append('.')
elif self.field[self.pos] == '@':
# bpo-34155: Don't parse domains with two `@` like
# `a@malicious.org@important.com`.
return EMPTYSTRING
elif self.field[self.pos] in self.atomends:
break
else:
sdlist.append(self.getatom())
return EMPTYSTRING.join(sdlist)
def getdelimited(self, beginchar, endchars, allowcomments=True):
"""Parse a header fragment delimited by special characters.
`beginchar' is the start character for the fragment.
If self is not looking at an instance of `beginchar' then
getdelimited returns the empty string.
`endchars' is a sequence of allowable end-delimiting characters.
Parsing stops when one of these is encountered.
If `allowcomments' is non-zero, embedded RFC 2822 comments are allowed
within the parsed fragment.
"""
if self.field[self.pos] != beginchar:
return ''
slist = ['']
quote = False
self.pos += 1
while self.pos < len(self.field):
if quote:
slist.append(self.field[self.pos])
quote = False
elif self.field[self.pos] in endchars:
self.pos += 1
break
elif allowcomments and self.field[self.pos] == '(':
slist.append(self.getcomment())
continue # have already advanced pos from getcomment
elif self.field[self.pos] == '\\':
quote = True
else:
slist.append(self.field[self.pos])
self.pos += 1
return EMPTYSTRING.join(slist)
def getquote(self):
"""Get a quote-delimited fragment from self's field."""
return self.getdelimited('"', '"\r', False)
def getcomment(self):
"""Get a parenthesis-delimited fragment from self's field."""
return self.getdelimited('(', ')\r', True)
def getdomainliteral(self):
"""Parse an RFC 2822 domain-literal."""
return '[%s]' % self.getdelimited('[', ']\r', False)
def getatom(self, atomends=None):
"""Parse an RFC 2822 atom.
Optional atomends specifies a different set of end token delimiters
(the default is to use self.atomends). This is used e.g. in
getphraselist() since phrase endings must not include the `.' (which
is legal in phrases)."""
atomlist = ['']
if atomends is None:
atomends = self.atomends
while self.pos < len(self.field):
if self.field[self.pos] in atomends:
break
else:
atomlist.append(self.field[self.pos])
self.pos += 1
return EMPTYSTRING.join(atomlist)
def getphraselist(self):
"""Parse a sequence of RFC 2822 phrases.
A phrase is a sequence of words, which are in turn either RFC 2822
atoms or quoted-strings. Phrases are canonicalized by squeezing all
runs of continuous whitespace into one space.
"""
plist = []
while self.pos < len(self.field):
if self.field[self.pos] in self.FWS:
self.pos += 1
elif self.field[self.pos] == '"':
plist.append(self.getquote())
elif self.field[self.pos] == '(':
self.commentlist.append(self.getcomment())
elif self.field[self.pos] in self.phraseends:
break
else:
plist.append(self.getatom(self.phraseends))
return plist
class AddressList(AddrlistClass):
"""An AddressList encapsulates a list of parsed RFC 2822 addresses."""
def __init__(self, field):
AddrlistClass.__init__(self, field)
if field:
self.addresslist = self.getaddrlist()
else:
self.addresslist = []
def __len__(self):
return len(self.addresslist)
def __add__(self, other):
# Set union
newaddr = AddressList(None)
newaddr.addresslist = self.addresslist[:]
for x in other.addresslist:
if not x in self.addresslist:
newaddr.addresslist.append(x)
return newaddr
def __iadd__(self, other):
# Set union, in-place
for x in other.addresslist:
if not x in self.addresslist:
self.addresslist.append(x)
return self
def __sub__(self, other):
# Set difference
newaddr = AddressList(None)
for x in self.addresslist:
if not x in other.addresslist:
newaddr.addresslist.append(x)
return newaddr
def __isub__(self, other):
# Set difference, in-place
for x in other.addresslist:
if x in self.addresslist:
self.addresslist.remove(x)
return self
def __getitem__(self, index):
# Make indexing, slices, and 'in' work
return self.addresslist[index]
PK ! /PL! L! _encoded_words.pynu [ """ Routines for manipulating RFC2047 encoded words.
This is currently a package-private API, but will be considered for promotion
to a public API if there is demand.
"""
# An ecoded word looks like this:
#
# =?charset[*lang]?cte?encoded_string?=
#
# for more information about charset see the charset module. Here it is one
# of the preferred MIME charset names (hopefully; you never know when parsing).
# cte (Content Transfer Encoding) is either 'q' or 'b' (ignoring case). In
# theory other letters could be used for other encodings, but in practice this
# (almost?) never happens. There could be a public API for adding entries
# to the CTE tables, but YAGNI for now. 'q' is Quoted Printable, 'b' is
# Base64. The meaning of encoded_string should be obvious. 'lang' is optional
# as indicated by the brackets (they are not part of the syntax) but is almost
# never encountered in practice.
#
# The general interface for a CTE decoder is that it takes the encoded_string
# as its argument, and returns a tuple (cte_decoded_string, defects). The
# cte_decoded_string is the original binary that was encoded using the
# specified cte. 'defects' is a list of MessageDefect instances indicating any
# problems encountered during conversion. 'charset' and 'lang' are the
# corresponding strings extracted from the EW, case preserved.
#
# The general interface for a CTE encoder is that it takes a binary sequence
# as input and returns the cte_encoded_string, which is an ascii-only string.
#
# Each decoder must also supply a length function that takes the binary
# sequence as its argument and returns the length of the resulting encoded
# string.
#
# The main API functions for the module are decode, which calls the decoder
# referenced by the cte specifier, and encode, which adds the appropriate
# RFC 2047 "chrome" to the encoded string, and can optionally automatically
# select the shortest possible encoding. See their docstrings below for
# details.
import re
import base64
import binascii
import functools
from string import ascii_letters, digits
from email import errors
__all__ = ['decode_q',
'encode_q',
'decode_b',
'encode_b',
'len_q',
'len_b',
'decode',
'encode',
]
#
# Quoted Printable
#
# regex based decoder.
_q_byte_subber = functools.partial(re.compile(br'=([a-fA-F0-9]{2})').sub,
lambda m: bytes.fromhex(m.group(1).decode()))
def decode_q(encoded):
encoded = encoded.replace(b'_', b' ')
return _q_byte_subber(encoded), []
# dict mapping bytes to their encoded form
class _QByteMap(dict):
safe = b'-!*+/' + ascii_letters.encode('ascii') + digits.encode('ascii')
def __missing__(self, key):
if key in self.safe:
self[key] = chr(key)
else:
self[key] = "={:02X}".format(key)
return self[key]
_q_byte_map = _QByteMap()
# In headers spaces are mapped to '_'.
_q_byte_map[ord(' ')] = '_'
def encode_q(bstring):
return ''.join(_q_byte_map[x] for x in bstring)
def len_q(bstring):
return sum(len(_q_byte_map[x]) for x in bstring)
#
# Base64
#
def decode_b(encoded):
# First try encoding with validate=True, fixing the padding if needed.
# This will succeed only if encoded includes no invalid characters.
pad_err = len(encoded) % 4
missing_padding = b'==='[:4-pad_err] if pad_err else b''
try:
return (
base64.b64decode(encoded + missing_padding, validate=True),
[errors.InvalidBase64PaddingDefect()] if pad_err else [],
)
except binascii.Error:
# Since we had correct padding, this is likely an invalid char error.
#
# The non-alphabet characters are ignored as far as padding
# goes, but we don't know how many there are. So try without adding
# padding to see if it works.
try:
return (
base64.b64decode(encoded, validate=False),
[errors.InvalidBase64CharactersDefect()],
)
except binascii.Error:
# Add as much padding as could possibly be necessary (extra padding
# is ignored).
try:
return (
base64.b64decode(encoded + b'==', validate=False),
[errors.InvalidBase64CharactersDefect(),
errors.InvalidBase64PaddingDefect()],
)
except binascii.Error:
# This only happens when the encoded string's length is 1 more
# than a multiple of 4, which is invalid.
#
# bpo-27397: Just return the encoded string since there's no
# way to decode.
return encoded, [errors.InvalidBase64LengthDefect()]
def encode_b(bstring):
return base64.b64encode(bstring).decode('ascii')
def len_b(bstring):
groups_of_3, leftover = divmod(len(bstring), 3)
# 4 bytes out for each 3 bytes (or nonzero fraction thereof) in.
return groups_of_3 * 4 + (4 if leftover else 0)
_cte_decoders = {
'q': decode_q,
'b': decode_b,
}
def decode(ew):
"""Decode encoded word and return (string, charset, lang, defects) tuple.
An RFC 2047/2243 encoded word has the form:
=?charset*lang?cte?encoded_string?=
where '*lang' may be omitted but the other parts may not be.
This function expects exactly such a string (that is, it does not check the
syntax and may raise errors if the string is not well formed), and returns
the encoded_string decoded first from its Content Transfer Encoding and
then from the resulting bytes into unicode using the specified charset. If
the cte-decoded string does not successfully decode using the specified
character set, a defect is added to the defects list and the unknown octets
are replaced by the unicode 'unknown' character \\uFDFF.
The specified charset and language are returned. The default for language,
which is rarely if ever encountered, is the empty string.
"""
_, charset, cte, cte_string, _ = ew.split('?')
charset, _, lang = charset.partition('*')
cte = cte.lower()
# Recover the original bytes and do CTE decoding.
bstring = cte_string.encode('ascii', 'surrogateescape')
bstring, defects = _cte_decoders[cte](bstring)
# Turn the CTE decoded bytes into unicode.
try:
string = bstring.decode(charset)
except UnicodeError:
defects.append(errors.UndecodableBytesDefect("Encoded word "
"contains bytes not decodable using {} charset".format(charset)))
string = bstring.decode(charset, 'surrogateescape')
except LookupError:
string = bstring.decode('ascii', 'surrogateescape')
if charset.lower() != 'unknown-8bit':
defects.append(errors.CharsetError("Unknown charset {} "
"in encoded word; decoded as unknown bytes".format(charset)))
return string, charset, lang, defects
_cte_encoders = {
'q': encode_q,
'b': encode_b,
}
_cte_encode_length = {
'q': len_q,
'b': len_b,
}
def encode(string, charset='utf-8', encoding=None, lang=''):
"""Encode string using the CTE encoding that produces the shorter result.
Produces an RFC 2047/2243 encoded word of the form:
=?charset*lang?cte?encoded_string?=
where '*lang' is omitted unless the 'lang' parameter is given a value.
Optional argument charset (defaults to utf-8) specifies the charset to use
to encode the string to binary before CTE encoding it. Optional argument
'encoding' is the cte specifier for the encoding that should be used ('q'
or 'b'); if it is None (the default) the encoding which produces the
shortest encoded sequence is used, except that 'q' is preferred if it is up
to five characters longer. Optional argument 'lang' (default '') gives the
RFC 2243 language string to specify in the encoded word.
"""
if charset == 'unknown-8bit':
bstring = string.encode('ascii', 'surrogateescape')
else:
bstring = string.encode(charset)
if encoding is None:
qlen = _cte_encode_length['q'](bstring)
blen = _cte_encode_length['b'](bstring)
# Bias toward q. 5 is arbitrary.
encoding = 'q' if qlen - blen < 5 else 'b'
encoded = _cte_encoders[encoding](bstring)
if lang:
lang = '*' + lang
return "=?{}{}?{}?{}?=".format(charset, lang, encoding, encoded)
PK ! Y% Y% architecture.rstnu [ :mod:`email` Package Architecture
=================================
Overview
--------
The email package consists of three major components:
Model
An object structure that represents an email message, and provides an
API for creating, querying, and modifying a message.
Parser
Takes a sequence of characters or bytes and produces a model of the
email message represented by those characters or bytes.
Generator
Takes a model and turns it into a sequence of characters or bytes. The
sequence can either be intended for human consumption (a printable
unicode string) or bytes suitable for transmission over the wire. In
the latter case all data is properly encoded using the content transfer
encodings specified by the relevant RFCs.
Conceptually the package is organized around the model. The model provides both
"external" APIs intended for use by application programs using the library,
and "internal" APIs intended for use by the Parser and Generator components.
This division is intentionally a bit fuzzy; the API described by this
documentation is all a public, stable API. This allows for an application
with special needs to implement its own parser and/or generator.
In addition to the three major functional components, there is a third key
component to the architecture:
Policy
An object that specifies various behavioral settings and carries
implementations of various behavior-controlling methods.
The Policy framework provides a simple and convenient way to control the
behavior of the library, making it possible for the library to be used in a
very flexible fashion while leveraging the common code required to parse,
represent, and generate message-like objects. For example, in addition to the
default :rfc:`5322` email message policy, we also have a policy that manages
HTTP headers in a fashion compliant with :rfc:`2616`. Individual policy
controls, such as the maximum line length produced by the generator, can also
be controlled individually to meet specialized application requirements.
The Model
---------
The message model is implemented by the :class:`~email.message.Message` class.
The model divides a message into the two fundamental parts discussed by the
RFC: the header section and the body. The `Message` object acts as a
pseudo-dictionary of named headers. Its dictionary interface provides
convenient access to individual headers by name. However, all headers are kept
internally in an ordered list, so that the information about the order of the
headers in the original message is preserved.
The `Message` object also has a `payload` that holds the body. A `payload` can
be one of two things: data, or a list of `Message` objects. The latter is used
to represent a multipart MIME message. Lists can be nested arbitrarily deeply
in order to represent the message, with all terminal leaves having non-list
data payloads.
Message Lifecycle
-----------------
The general lifecycle of a message is:
Creation
A `Message` object can be created by a Parser, or it can be
instantiated as an empty message by an application.
Manipulation
The application may examine one or more headers, and/or the
payload, and it may modify one or more headers and/or
the payload. This may be done on the top level `Message`
object, or on any sub-object.
Finalization
The Model is converted into a unicode or binary stream,
or the model is discarded.
Header Policy Control During Lifecycle
--------------------------------------
One of the major controls exerted by the Policy is the management of headers
during the `Message` lifecycle. Most applications don't need to be aware of
this.
A header enters the model in one of two ways: via a Parser, or by being set to
a specific value by an application program after the Model already exists.
Similarly, a header exits the model in one of two ways: by being serialized by
a Generator, or by being retrieved from a Model by an application program. The
Policy object provides hooks for all four of these pathways.
The model storage for headers is a list of (name, value) tuples.
The Parser identifies headers during parsing, and passes them to the
:meth:`~email.policy.Policy.header_source_parse` method of the Policy. The
result of that method is the (name, value) tuple to be stored in the model.
When an application program supplies a header value (for example, through the
`Message` object `__setitem__` interface), the name and the value are passed to
the :meth:`~email.policy.Policy.header_store_parse` method of the Policy, which
returns the (name, value) tuple to be stored in the model.
When an application program retrieves a header (through any of the dict or list
interfaces of `Message`), the name and value are passed to the
:meth:`~email.policy.Policy.header_fetch_parse` method of the Policy to
obtain the value returned to the application.
When a Generator requests a header during serialization, the name and value are
passed to the :meth:`~email.policy.Policy.fold` method of the Policy, which
returns a string containing line breaks in the appropriate places. The
:meth:`~email.policy.Policy.cte_type` Policy control determines whether or
not Content Transfer Encoding is performed on the data in the header. There is
also a :meth:`~email.policy.Policy.binary_fold` method for use by generators
that produce binary output, which returns the folded header as binary data,
possibly folded at different places than the corresponding string would be.
Handling Binary Data
--------------------
In an ideal world all message data would conform to the RFCs, meaning that the
parser could decode the message into the idealized unicode message that the
sender originally wrote. In the real world, the email package must also be
able to deal with badly formatted messages, including messages containing
non-ASCII characters that either have no indicated character set or are not
valid characters in the indicated character set.
Since email messages are *primarily* text data, and operations on message data
are primarily text operations (except for binary payloads of course), the model
stores all text data as unicode strings. Un-decodable binary inside text
data is handled by using the `surrogateescape` error handler of the ASCII
codec. As with the binary filenames the error handler was introduced to
handle, this allows the email package to "carry" the binary data received
during parsing along until the output stage, at which time it is regenerated
in its original form.
This carried binary data is almost entirely an implementation detail. The one
place where it is visible in the API is in the "internal" API. A Parser must
do the `surrogateescape` encoding of binary input data, and pass that data to
the appropriate Policy method. The "internal" interface used by the Generator
to access header values preserves the `surrogateescaped` bytes. All other
interfaces convert the binary data either back into bytes or into a safe form
(losing information in some cases).
Backward Compatibility
----------------------
The :class:`~email.policy.Policy.Compat32` Policy provides backward
compatibility with version 5.1 of the email package. It does this via the
following implementation of the four+1 Policy methods described above:
header_source_parse
Splits the first line on the colon to obtain the name, discards any spaces
after the colon, and joins the remainder of the line with all of the
remaining lines, preserving the linesep characters to obtain the value.
Trailing carriage return and/or linefeed characters are stripped from the
resulting value string.
header_store_parse
Returns the name and value exactly as received from the application.
header_fetch_parse
If the value contains any `surrogateescaped` binary data, return the value
as a :class:`~email.header.Header` object, using the character set
`unknown-8bit`. Otherwise just returns the value.
fold
Uses :class:`~email.header.Header`'s folding to fold headers in the
same way the email5.1 generator did.
binary_fold
Same as fold, but encodes to 'ascii'.
New Algorithm
-------------
header_source_parse
Same as legacy behavior.
header_store_parse
Same as legacy behavior.
header_fetch_parse
If the value is already a header object, returns it. Otherwise, parses the
value using the new parser, and returns the resulting object as the value.
`surrogateescaped` bytes get turned into unicode unknown character code
points.
fold
Uses the new header folding algorithm, respecting the policy settings.
surrogateescaped bytes are encoded using the ``unknown-8bit`` charset for
``cte_type=7bit`` or ``8bit``. Returns a string.
At some point there will also be a ``cte_type=unicode``, and for that
policy fold will serialize the idealized unicode message with RFC-like
folding, converting any surrogateescaped bytes into the unicode
unknown character glyph.
binary_fold
Uses the new header folding algorithm, respecting the policy settings.
surrogateescaped bytes are encoded using the `unknown-8bit` charset for
``cte_type=7bit``, and get turned back into bytes for ``cte_type=8bit``.
Returns bytes.
At some point there will also be a ``cte_type=unicode``, and for that
policy binary_fold will serialize the message according to :rfc:``5335``.
PK ! "}Ht t / __pycache__/_encoded_words.cpython-36.opt-2.pycnu [ 3
\F! @ s d dl Z d dlZd dlZd dlZd dlmZmZ d dlmZ dddddd d
d gZ ej
e j d j d
d Z
dd ZG dd deZe Zdeed< dd Zdd Zdd Zdd Zdd ZeedZdd
ZeedZeedZd d d Z dS ) N)
ascii_lettersdigits)errorsdecode_qencode_qdecode_bencode_blen_qlen_bdecodeencodes =([a-fA-F0-9]{2})c C s t t| jddgS )N )bytesintgroup)m r ,/usr/lib64/python3.6/email/_encoded_words.pyA s r c C s | j dd} t| g fS )N _ )replace_q_byte_subber)encodedr r r r C s c @ s, e Zd Zdejd ejd Zdd ZdS ) _QByteMaps -!*+/asciic C s. || j krt|| |< ndj|| |< | | S )Nz={:02X})safechrformat)selfkeyr r r __missing__M s
z_QByteMap.__missing__N)__name__
__module__ __qualname__r r r r r" r r r r r I s r _ c C s dj dd | D S )N c s s | ]}t | V qd S )N) _q_byte_map).0xr r r Z s zencode_q..)join)bstringr r r r Y s c C s t dd | D S )Nc s s | ]}t t| V qd S )N)lenr) )r* r+ r r r r, ] s zlen_q..)sum)r. r r r r \ s c C s t | d }|r dd d| nd}y$tj| | dd|rDtj gng fS tjk
r ytj| ddtj gfS tjk
r y"tj| d ddtj tj gfS tjk
r | tj gfS X Y nX Y nX d S )N s === T)ZvalidateFs ==) r/ base64Z b64decoder ZInvalidBase64PaddingDefectbinasciiErrorZ InvalidBase64CharactersDefectZInvalidBase64LengthDefect)r Zpad_errZmissing_paddingr r r r d s c C s t j| jdS )Nr )r3 Z b64encoder )r. r r r r s c C s& t t| d\}}|d |r dnd S )N r1 r )divmodr/ )r. Z groups_of_3Zleftoverr r r r
s )qbc C s | j d\}}}}}|jd\}}}|j }|jdd}t| |\}}y|j|}W nv tk
r |jtj dj
| |j|d}Y nB t k
r |jdd}|j dkr|jtj dj
| Y nX ||||fS )N?*r surrogateescapez:Encoded word contains bytes not decodable using {} charsetz unknown-8bitz* s@
&+PK ! דM; ; , __pycache__/_policybase.cpython-36.opt-1.pycnu [ 3
Ii< @ s d Z ddlZddlmZ ddlmZ ddlmZ dddgZG d d
d
Z d d Z
d
d Z G dd de ej dZ
e G dd de
Ze ZdS )zwPolicy framework for the email package.
Allows fine grained feature control of how the package parses and emits data.
N)header)charset)_has_surrogatesPolicyCompat32compat32c s@ e Zd ZdZ fddZdd Zdd Zdd Zd
d Z Z S ) _PolicyBasea Policy Object basic framework.
This class is useless unless subclassed. A subclass should define
class attributes with defaults for any values that are to be
managed by the Policy object. The constructor will then allow
non-default values to be set for these attributes at instance
creation time. The instance will be callable, taking these same
attributes keyword arguments, and returning a new instance
identical to the called instance except for those values changed
by the keyword arguments. Instances may be added, yielding new
instances with any non-default values from the right hand
operand overriding those in the left hand operand. That is,
A + B == A()
The repr of an instance can be used to reconstruct the object
if and only if the repr of the values can be used to reconstruct
those values.
c sL xF|j D ]:\}}t| |r0tt| j|| q
tdj|| jjq
W dS )zCreate new Policy, possibly overriding some defaults.
See class docstring for a list of overridable attributes.
z*{!r} is an invalid keyword argument for {}N) itemshasattrsuperr __setattr__ TypeErrorformat __class____name__)selfkwnamevalue)r )/usr/lib64/python3.6/email/_policybase.py__init__) s
z_PolicyBase.__init__c C s* dd | j j D }dj| jjdj|S )Nc S s g | ]\}}d j ||qS )z{}={!r})r ).0r r r r r
8 s z(_PolicyBase.__repr__..z{}({})z, )__dict__r r r r join)r argsr r r __repr__7 s z_PolicyBase.__repr__c K sz | j j| j }x$| jj D ]\}}tj||| qW x@|j D ]4\}}t| |sdtdj|| j j tj||| q>W |S )zReturn a new instance with specified attributes changed.
The new instance has the same attribute values as the current object,
except for the changes passed in as keyword arguments.
z*{!r} is an invalid keyword argument for {})
r __new__r r objectr r
r
r r )r r Z newpolicyattrr r r r clone< s
z_PolicyBase.clonec C s, t | |rd}nd}t|j| jj|d S )Nz'{!r} object attribute {!r} is read-onlyz!{!r} object has no attribute {!r})r
AttributeErrorr r r )r r r msgr r r r N s
z_PolicyBase.__setattr__c C s | j f |jS )zNon-default values from right operand override those from left.
The object returned is a new instance of the subclass.
)r! r )r otherr r r __add__U s z_PolicyBase.__add__)
r
__module__ __qualname____doc__r r r! r r%
__classcell__r r )r r r s r c C s, | j ddd } |jddd }| d | S )N
r )rsplitsplit)docZ added_docr r r _append_doc^ s r/ c C s | j r(| j jdr(t| jd j | j | _ xf| jj D ]X\}}|j r4|j jdr4xh s z%_extend_docstrings..r( )r(
startswithr/ __bases__r r getattr)clsr r r3 r. r r r _extend_docstringsc s
r9 c @ s e Zd ZdZdZdZdZdZdZdZ dZ
dd Z d
d Z d d
Z
ejdd Zejdd Zejdd Zejdd Zejdd ZdS )r a
Controls for how messages are interpreted and formatted.
Most of the classes and many of the methods in the email package accept
Policy objects as parameters. A Policy object contains a set of values and
functions that control how input is interpreted and how output is rendered.
For example, the parameter 'raise_on_defect' controls whether or not an RFC
violation results in an error being raised or not, while 'max_line_length'
controls the maximum length of output lines when a Message is serialized.
Any valid attribute may be overridden when a Policy is created by passing
it as a keyword argument to the constructor. Policy objects are immutable,
but a new Policy object can be created with only certain values changed by
calling the Policy instance with keyword arguments. Policy objects can
also be added, producing a new Policy object in which the non-default
attributes set in the right hand operand overwrite those specified in the
left operand.
Settable attributes:
raise_on_defect -- If true, then defects should be raised as errors.
Default: False.
linesep -- string containing the value to use as separation
between output lines. Default '\n'.
cte_type -- Type of allowed content transfer encodings
7bit -- ASCII only
8bit -- Content-Transfer-Encoding: 8bit is allowed
Default: 8bit. Also controls the disposition of
(RFC invalid) binary data in headers; see the
documentation of the binary_fold method.
max_line_length -- maximum length of lines, excluding 'linesep',
during serialization. None or 0 means no line
wrapping is done. Default is 78.
mangle_from_ -- a flag that, when True escapes From_ lines in the
body of the message by putting a `>' in front of
them. This is used when the message is being
serialized by a generator. Default: True.
message_factory -- the class to use to create new message objects.
If the value is None, the default is Message.
verify_generated_headers
-- if true, the generator verifies that each header
they are properly folded, so that a parser won't
treat it as multiple headers, start-of-body, or
part of another header.
This is a check against custom Header & fold()
implementations.
Fr* Z8bitN NTc C s | j r
|| j|| dS )aZ Based on policy, either raise defect or call register_defect.
handle_defect(obj, defect)
defect should be a Defect subclass, but in any case must be an
Exception subclass. obj is the object on which the defect should be
registered if it is not raised. If the raise_on_defect is True, the
defect is raised as an error, otherwise the object and the defect are
passed to register_defect.
This method is intended to be called by parsers that discover defects.
The email package parsers always call it with Defect instances.
N)raise_on_defectregister_defect)r objdefectr r r
handle_defect s zPolicy.handle_defectc C s |j j| dS )a Record 'defect' on 'obj'.
Called by handle_defect if raise_on_defect is False. This method is
part of the Policy API so that Policy subclasses can implement custom
defect handling. The default implementation calls the append method of
the defects attribute of obj. The objects used by the email package by
default that get passed to this method will always have a defects
attribute with an append method.
N)Zdefectsappend)r r= r> r r r r< s zPolicy.register_defectc C s dS )a[ Return the maximum allowed number of headers named 'name'.
Called when a header is added to a Message object. If the returned
value is not 0 or None, and there are already a number of headers with
the name 'name' equal to the value returned, a ValueError is raised.
Because the default behavior of Message's __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.)
The default implementation returns None for all header names.
Nr )r r r r r header_max_count s zPolicy.header_max_countc C s t dS )aZ Given a list of linesep terminated strings constituting the lines of
a single header, return the (name, value) tuple that should be stored
in the model. The input lines should retain their terminating linesep
characters. The lines passed in by the email package may contain
surrogateescaped binary data.
N)NotImplementedError)r sourcelinesr r r header_source_parse s zPolicy.header_source_parsec C s t dS )zGiven the header name and the value provided by the application
program, return the (name, value) that should be stored in the model.
N)rB )r r r r r r header_store_parse s zPolicy.header_store_parsec C s t dS )aw Given the header name and the value from the model, return the value
to be returned to the application program that is requesting that
header. The value passed in by the email package may contain
surrogateescaped binary data if the lines were parsed by a BytesParser.
The returned value should not contain any surrogateescaped data.
N)rB )r r r r r r header_fetch_parse s zPolicy.header_fetch_parsec C s t dS )a Given the header name and the value from the model, return a string
containing linesep characters that implement the folding of the header
according to the policy controls. The value passed in by the email
package may contain surrogateescaped binary data if the lines were
parsed by a BytesParser. The returned value should not contain any
surrogateescaped data.
N)rB )r r r r r r fold s
z Policy.foldc C s t dS )a% Given the header name and the value from the model, return binary
data containing linesep characters that implement the folding of the
header according to the policy controls. The value passed in by the
email package may contain surrogateescaped binary data.
N)rB )r r r r r r fold_binary s zPolicy.fold_binary)r r& r' r( r; linesepcte_typemax_line_length mangle_from_Zmessage_factoryZverify_generated_headersr? r< rA abcabstractmethodrD rE rF rG rH r r r r r p s 7
) metaclassc @ sL e Zd ZdZdZdd Zdd Zdd Zd d
Zd d Z d
d Z
dd Z dS )r z+
This particular policy is the backward compatibility Policy. It
replicates the behavior of the email package version 5.1.
Tc C s0 t |ts|S t|r(tj|tj|dS |S d S )N)r header_name)
isinstancestrr r Header_charset UNKNOWN8BIT)r r r r r r _sanitize_header! s
zCompat32._sanitize_headerc C s> |d j dd\}}|jddj|dd }||jdfS )a: +
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.
r :r+ z Nz
)r- lstripr rstrip)r rC r r r r r rD - s z Compat32.header_source_parsec C s ||fS )z>+
The name and value are returned unmodified.
r )r r r r r r rE 9 s zCompat32.header_store_parsec C s | j ||S )z+
If the value contains binary data, it is converted into a Header object
using the unknown-8bit charset. Otherwise it is returned unmodified.
)rV )r r r r r r rF ? s zCompat32.header_fetch_parsec C s | j ||ddS )a +
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 charset.
T)sanitize)_fold)r r r r r r rG F s z
Compat32.foldc C s" | j ||| jdkd}|jddS )a +
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. If 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/or binary data.
Z7bit)r[ asciisurrogateescape)r\ rJ encode)r r r Zfoldedr r r rH P s zCompat32.fold_binaryc C s g }|j d| t|tr\t|rL|r s L
( fPK !
s0 0 % __pycache__/_parseaddr.cpython-36.pycnu [ 3
IiD @ s d Z ddddgZddlZddlZdZdZd Zd
d d d
dddddddddddddddd d d d d gZd!d"d#d$d%d&d'gZddddd9d:d;dd?d@dAdBd.Z d/d Z
d0d1 Z d2d Z d3d Z
d4d ZG d5d6 d6ZG d7d8 d8eZdS )CzcEmail address parsing code.
Lifted directly from rfc822.py. This should eventually be rewritten.
mktime_tz parsedate parsedate_tzquote N z, ZjanZfebZmarZaprZmayZjunZjulZaugsepoctZnovZdecZjanuaryZfebruaryZmarchZaprilZjuneZjulyZaugustZ septemberZoctoberZnovemberZdecemberZmonZtueZwedZthuZfriZsatZsuni i, i iX i i )ZUTZUTCZGMTZZASTZADTZESTZEDTZCSTZCDTZMSTZMDTZPSTZPDTc C s, t | }|sdS |d dkr$d|d< t|S )zQConvert a date string to a time tuple.
Accounts for military timezones.
N r )
_parsedate_tztuple)datares r (/usr/lib64/python3.6/email/_parseaddr.pyr - s c C s | sdS | j } | d jds.| d j tkr6| d= n.| d jd}|dkrd| d |d d | d< t| dkr| d j d}t|dkr|| dd } t| dkr | d }|jd}|dkr|jd}|dkr|d| ||d g| dd< n
| jd t| d
k rdS | dd
} | \}}}}}|j }|tkrZ||j }}|tkrZdS tj |d }|d krz|d 8 }|d dkr|dd }|jd }|dkr|| }}|d dkr|dd }|d j
s|| }}|d dkr|dd }|j d }t|d
kr$|\} }
d} n~t|dkr>|\} }
} ndt|dkrd|d kr|d j d}t|d
kr|\} }
d} nt|dkr|\} }
} ndS y,t |}t |}t | } t |
}
t | } W n t k
r dS X |dk r |dkr|d7 }n|d7 }d} |j
}|tkr,t| } n>y t |} W n t k
rN Y nX | dkrj|jdrjd} | r| dk rd }
| } nd}
|
| d d | d d } |||| |
| ddd | g
S ) a Convert date to extended time tuple.
The last (additional) element is the time zone offset in seconds, except if
the timezone was specified as -0000. In that case the last element is
None. This indicates a UTC timestamp that explicitly declaims knowledge of
the source timezone, as opposed to a +0000 timestamp that indicates the
source timezone really was UTC.
Nr , - +r : 0.d D il i i < r! r! r! r! r! r! r! r! )splitendswithlower _daynamesrfindlenfindappend _monthnamesindexisdigitint
ValueErrorupper
_timezones
startswith)r iZstuffsZddZmmZyyZtmZtzZthhZtmmZtssZtzoffsetZtzsignr r r r 9 s
"
r c C s& t | }t|tr |dd S |S dS )z&Convert a time string to a time tuple.Nr )r
isinstancer
)r tr r r r s
c C s< | d dkr"t j| dd d S tj| }|| d S dS )zETurn a 10-tuple as returned by parsedate_tz() into a POSIX timestamp.r N r r! )r! )timeZmktimecalendarZtimegm)r r5 r r r r s
c C s | j ddj ddS )zPrepare string to be used in a quoted string.
Turns backslash and double quote characters into quoted pairs. These
are the only characters that need to be quoted inside a quoted string.
Does not add the surrounding double quotes.
\z\\"z\")replace)strr r r r s c @ s| e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
d ddZ dd Z dd Z
dd Zd ddZd d ZdS )
AddrlistClassa Address parser class by Ben Escoto.
To understand what this class does, it helps to have a copy of RFC 2822 in
front of you.
Note: this class interface is deprecated and may be removed in the future.
Use email.utils.AddressList instead.
c C sZ d| _ d| _d| _d| _| j| j | _| j | j | j | _| jjdd| _|| _g | _ dS )zInitialize a new instance.
`field' is an unparsed address header field, containing
one or more addresses.
z ()<>@,:;."[]r z z
r r N)
specialsposLWSZCRFWSatomendsr;
phraseendsfield commentlist)selfrD r r r __init__ s zAddrlistClass.__init__c C s g }x| j t| jk r| j| j | jd kr^| j| j dkrN|j| j| j | j d7 _ q| j| j dkr| jj| j qP qW tj|S )z&Skip white space and extract comments.z
r () r? r' rD r@ r) rE
getcomment EMPTYSTRINGjoin)rF Zwslistr r r gotonext s zAddrlistClass.gotonextc C s> g }x4| j t| jk r8| j }|r,||7 }q|jd qW |S )zVParse all addresses.
Returns a list containing all of the addresses.
r )r r )r? r' rD
getaddressr) )rF resultZadr r r getaddrlist s
zAddrlistClass.getaddrlistc C s g | _ | j | j}| j }| j }| j g }| jt| jkr\|rXtj| j |d fg}n\| j| j dkr|| _|| _ | j }tj| j |fg}n"| j| j dkr g }t| j}| jd7 _x| jt| jk r| j | j|k o| j| j dkr | jd7 _P || j }qW n| j| j dkrx| j
}| j rftj|d dj| j d |fg}ntj||fg}n@|rtj| j |d fg}n"| j| j | j kr| jd7 _| j | jt| jk r| j| j d
kr| jd7 _|S ) zParse the next address.r z.@r r ; )rF ZoldposZoldclplistZ
returnlistZaddrspecZfieldlenZ routeaddrr r r rM sL
&$zAddrlistClass.getaddressc C s | j | j dkrdS d}| jd7 _| j d}x| jt| j k r|rV| j d}n~| j | j dkrx| jd7 _P n\| j | j dkr| jd7 _d}n8| j | j d kr| jd7 _n| j }| jd7 _P | j q4W |S )
zParse a route address (Return-path value).
This method just skips all the route stuff and returns the addrspec.
rQ NFr r >@Tr )rD r? rL r' getdomainrU )rF Z expectrouteZadlistr r r rV ? s. zAddrlistClass.getrouteaddrc C s\ g }| j x| jt| jk rd}| j| j dkrj|rL|d j rL|j |jd | jd7 _d}nf| j| j dkr|jdt| j n>| j| j | j kr|r|d j r|j P n|j| j
| j }|r|r|j| qW | jt| jks| j| j dkr t j |S |jd | jd7 _| j | j
}|sNt S t j || S )
z Parse an RFC 2822 addr-spec.Tr r Fr: z"%s"rY r! r! )rL r? r' rD strippopr) r getquoterB getatomrJ rK rZ )rF ZaslistZ preserve_wsZwsZdomainr r r rU _ s:
$
zAddrlistClass.getaddrspecc C s g }x| j t| jk r| j| j | jkr8| j d7 _ q| j| j dkrZ| jj| j q| j| j dkrz|j| j q| j| j dkr| j d7 _ |jd q| j| j dkrtS | j| j | j krP q|j| j
qW tj |S )z-Get the complete domain name from an address.r rH [r rY ) r? r' rD r@ rE r) rI getdomainliteralrJ rB r^ rK )rF Zsdlistr r r rZ s" zAddrlistClass.getdomainTc C s | j | j |krdS dg}d}| jd7 _x| jt| j k r|rZ|j| j | j d}np| j | j |kr|| jd7 _P nN|r| j | j dkr|j| j q.n(| j | j dkrd}n|j| j | j | jd7 _q.W tj|S )a Parse a header fragment delimited by special characters.
`beginchar' is the start character for the fragment.
If self is not looking at an instance of `beginchar' then
getdelimited returns the empty string.
`endchars' is a sequence of allowable end-delimiting characters.
Parsing stops when one of these is encountered.
If `allowcomments' is non-zero, embedded RFC 2822 comments are allowed
within the parsed fragment.
r Fr rH r9 T)rD r? r' r) rI rJ rK )rF Z begincharZendcharsZ
allowcommentsZslistr r r r getdelimited s(
zAddrlistClass.getdelimitedc C s | j dddS )z1Get a quote-delimited fragment from self's field.r: z"
F)ra )rF r r r r] s zAddrlistClass.getquotec C s | j dddS )z7Get a parenthesis-delimited fragment from self's field.rH z)
T)ra )rF r r r rI s zAddrlistClass.getcommentc C s d| j ddd S )z!Parse an RFC 2822 domain-literal.z[%s]r_ z]
F)ra )rF r r r r` s z AddrlistClass.getdomainliteralNc C sh dg}|dkr| j }xH| jt| jk r\| j| j |kr:P n|j| j| j | jd7 _qW tj|S )a Parse an RFC 2822 atom.
Optional atomends specifies a different set of end token delimiters
(the default is to use self.atomends). This is used e.g. in
getphraselist() since phrase endings must not include the `.' (which
is legal in phrases).r Nr )rB r? r' rD r) rJ rK )rF rB Zatomlistr r r r^ s zAddrlistClass.getatomc C s g }x| j t| jk r| j| j | jkr8| j d7 _ q| j| j dkrX|j| j q| j| j dkrz| jj| j q| j| j | jkrP q|j| j | j qW |S )zParse a sequence of RFC 2822 phrases.
A phrase is a sequence of words, which are in turn either RFC 2822
atoms or quoted-strings. Phrases are canonicalized by squeezing all
runs of continuous whitespace into one space.
r r: rH )
r? r' rD rA r) r] rE rI rC r^ )rF rW r r r rS s zAddrlistClass.getphraselist)T)N)__name__
__module__ __qualname____doc__rG rL rO rM rV rU rZ ra r] rI r` r^ rS r r r r r= s ; &
%
r= c @ sH e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dS ) AddressListz@An AddressList encapsulates a list of parsed RFC 2822 addresses.c C s& t j| | |r | j | _ng | _d S )N)r= rG rO addresslist)rF rD r r r rG s zAddressList.__init__c C s
t | jS )N)r' rg )rF r r r __len__ s zAddressList.__len__c C sB t d }| jd d |_x$|jD ]}|| jkr |jj| q W |S )N)rf rg r) )rF othernewaddrxr r r __add__ s
zAddressList.__add__c C s* x$|j D ]}|| j kr| j j| qW | S )N)rg r) )rF ri rk r r r __iadd__
s
zAddressList.__iadd__c C s2 t d }x$| jD ]}||jkr|jj| qW |S )N)rf rg r) )rF ri rj rk r r r __sub__ s
zAddressList.__sub__c C s* x$|j D ]}|| j kr| j j| qW | S )N)rg remove)rF ri rk r r r __isub__ s
zAddressList.__isub__c C s
| j | S )N)rg )rF r+ r r r __getitem__# s zAddressList.__getitem__N) rb rc rd re rG rh rl rm rn rp rq r r r r rf s rf ipii ipii iDiiiD)re __all__r7 r8 rT rJ Z
COMMASPACEr* r% r0 r r r r r r= rf r r r r s8
u
/PK ! Za ) __pycache__/encoders.cpython-36.opt-2.pycnu [ 3
\ @ sP d dddgZ ddlmZ ddlmZ dd Zd d Zd
d Z d d Z
d d Z d
S )encode_7or8bit
encode_base64 encode_noop
encode_quopri ) encodebytes) encodestringc C s t | dd}|jddS )NT)Z quotetabs s =20)
_encodestringreplace)senc r
&/usr/lib64/python3.6/email/encoders.py_qencode s r c C s0 | j dd}tt|d}| j| d| d< d S )NT)decodeasciibase64zContent-Transfer-Encoding) get_payloadstr_bencode set_payload)msgorigencdatar
r
r r s
c C s* | j dd}t|}| j| d| d< d S )NT)r zquoted-printablezContent-Transfer-Encoding)r r r )r r r r
r
r r & s
c C sX | j dd}|d kr d| d< d S y|jd W n tk
rJ d| d< Y n
X d| d< d S )NT)r Z7bitzContent-Transfer-Encodingr Z8bit)r r UnicodeError)r r r
r
r r 2 s c C s d S )Nr
)r r
r
r r D s N) __all__r r r quoprir r r r r r r r
r
r
r s PK ! $f( ( + __pycache__/feedparser.cpython-36.opt-1.pycnu [ 3
\X @ s d Z ddgZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ej d Z ej d
Z
ej d Zej d
Zej d Zd
ZdZe ZG dd deZG dd dZG dd deZdS )a FeedParser - An email feed parser.
The feed parser implements an interface for incrementally parsing an email
message, line by line. This has advantages for certain applications, such as
those reading email messages off a socket.
FeedParser.feed() is the primary interface for pushing new data into the
parser. It returns when there's nothing more it can do with the available
data. When you have no more data to push into the parser, call .close().
This completes the parsing and returns the root message object.
The other advantage of this parser is that it will never raise a parsing
exception. Instead, when it finds something unexpected, it adds a 'defect' to
the current message. Defects are just instances that live on the message
object's .defects attribute.
FeedParserBytesFeedParser N)errors)compat32)deque)StringIOz
\r\n|\r|\nz (\r\n|\r|\n)z(\r\n|\r|\n)\Zz%^(From |[\041-\071\073-\176]*:|[\t ])
c @ s` e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dS )BufferedSubFileak A file-ish object that can have new data loaded into it.
You can also push and pop line-matching predicates onto a stack. When the
current predicate matches the current line, a false EOF response
(i.e. empty string) is returned instead. This lets the parser adhere to a
simple abstraction -- it parses until EOF closes the current message.
c C s$ t dd| _t | _g | _d| _d S )Nr )newlineF)r _partialr _lines _eofstack_closed)self r (/usr/lib64/python3.6/email/feedparser.py__init__5 s zBufferedSubFile.__init__c C s | j j| d S )N)r append)r Zpredr r r push_eof_matcher@ s z BufferedSubFile.push_eof_matcherc C s
| j j S )N)r pop)r r r r pop_eof_matcherC s z BufferedSubFile.pop_eof_matcherc C s< | j jd | j| j j | j jd | j j d| _d S )Nr T)r seek pushlines readlinestruncater )r r r r closeF s
zBufferedSubFile.closec C sN | j s| jrdS tS | j j }x*t| jD ] }||r*| j j| dS q*W |S )Nr )r
r NeedMoreDatapopleftreversedr
appendleft)r lineZateofr r r readlineN s
zBufferedSubFile.readlinec C s | j j| d S )N)r
r )r r! r r r
unreadline` s zBufferedSubFile.unreadlinec C sx | j j| d|kr d|kr dS | j jd | j j }| j jd | j j |d jdsj| j j|j | j| dS )z$Push some new data into this object.r
Nr )r writer r r endswithr r )r datapartsr r r pushe s
zBufferedSubFile.pushc C s | j j| d S )N)r
extend)r linesr r r r z s zBufferedSubFile.pushlinesc C s | S )Nr )r r r r __iter__} s zBufferedSubFile.__iter__c C s | j }|dkrt|S )Nr )r"
StopIteration)r r! r r r __next__ s zBufferedSubFile.__next__N)__name__
__module__ __qualname____doc__r r r r r" r# r+ r r. r0 r r r r r
- s r
c @ s` e Zd ZdZdedddZdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dS )r z A feed-style parser of email.N)policyc C s || _ d| _|dkr<|jdkr2ddlm} || _qn|j| _n2|| _y|| j d W n tk
rl d| _Y nX t | _g | _ | j
j | _ d| _
d| _d| _dS )a _factory is called with no arguments to create a new message obj
The policy keyword specifies a policy object that controls a number of
aspects of the parser's operation. The default policy maintains
backward compatibility.
FNr )Message)r5 T)r5 _old_style_factoryZmessage_factoryZ
email.messager6 _factory TypeErrorr
_input _msgstack _parsegenr0 _parse_cur_last _headersonly)r r8 r5 r6 r r r r s$
zFeedParser.__init__c C s
d| _ d S )NT)r@ )r r r r _set_headersonly s zFeedParser._set_headersonlyc C s | j j| | j dS )z Push more data into the parser.N)r: r+ _call_parse)r r) r r r feed s zFeedParser.feedc C s& y | j W n tk
r Y nX d S )N)r= r/ )r r r r rB s zFeedParser._call_parsec C sJ | j j | j | j }|j dkrF|j rFtj }| jj || |S )z get_content_typeZset_default_typer; Zattachr r? )r msgr r r _new_message s
zFeedParser._new_messagec C s( | j j }| j r | j d | _nd | _|S )Nr% r& )r; r r> )r retvalr r r rE s
zFeedParser._pop_messagec c s6 | j g }xb| jD ]X}|tkr(tV qtj|sbtj|s`tj }| jj | j
| | jj | P |j | qW | j
| | jrg }x2| jj }|tkrtV q|dkrP |j | qW | j
jtj| d S | j
j dkrx| jjtj x$| j D ]}|tkrtV qP qW | j }| jj x&| jj }|tkrFtV q(P q(W x&| jj }|tkrntV qPP qPW |dkrP | jj | qW d S | j
j dkrx(| j D ] }|tkrtV qP qW | j d S | j
j dkr| j
j }|d krbtj }| jj | j
| g }x.| jD ]$}|tkrtj+ }| jj | j
| | j
jtj| g }x$| jD ]}|tkrtV qqW tj|| j
_'d S |
s`tj, }| jj | j
| d S | rndg}ng }x.| jD ]$}|tkrtV qz|j | qzW |r|d }t-j|}|r|t$|j!dd |d< tj|| j
_'d S g }x.| jD ]$}|tkrtV q|j | qW | j
jtj| d S )Nr zmessage/delivery-statusmessagerD zcontent-transfer-encoding8bit7bitbinaryz--z(?Pz4)(?P--)?(?P[ \t]*)(?P\r\n|\r|\n)?$TFendlinesepr% r )rP rO rQ r& r& ).rL r: r headerREmatchNLCREr Z MissingHeaderBodySeparatorDefectr5 rG r> r# r _parse_headersr@ r" Z set_payload EMPTYSTRINGjoinrJ r r< rE r rF Z get_boundaryZNoBoundaryInMultipartDefectgetlowerZ-InvalidMultipartContentTransferEncodingDefectrecompileescapegroup NLCRE_eolsearchlenpreambler? epilogueZ_payload
isinstancestrZStartBoundaryNotFoundDefectZCloseBoundaryNotFoundDefect NLCRE_bol)r Zheadersr! rI r- rM rK boundaryZ separatorZ
boundaryreZcapturing_preamblerc rS Zclose_boundary_seenmoZlastlineZeolmord rR Zpayload firstlineZbolmor r r r< sf
zFeedParser._parsegenc C s^ d}g }x4t |D ]&\}}|d dkrV|sJtj|}| jj| j| q|j| q|rx| jj| jj| dg }}|j d r|dkrt
j |}|r|d t |j
d }| jj| qn:|t |d kr| jj| d S tj|}| jjj| q|jd}|dkr*tjd}| jjj| q|d | }|g}qW |rZ| jj| jj| d S )Nr r z zFrom r% :zMissing header name.) enumerater Z#FirstHeaderLineIsContinuationDefectr5 rG r> r Zset_rawZheader_source_parse
startswithr` ra rb r_ Z set_unixfromr: r# Z MisplacedEnvelopeHeaderDefectZdefectsfindZInvalidHeaderDefect) r r- Z
lastheaderZ lastvaluelinenor! rI ri ir r r rW sF
zFeedParser._parse_headers)N)r1 r2 r3 r4 r r rA rC rB r rL rE r< rW r r r r r s
~c s e Zd ZdZ fddZ ZS )r z(Like FeedParser, but feed accepts bytes.c s t j|jdd d S )Nasciisurrogateescape)superrC decode)r r) ) __class__r r rC s zBytesFeedParser.feed)r1 r2 r3 r4 rC
__classcell__r r )ru r r s )r4 __all__r\ Zemailr Zemail._policybaser collectionsr ior r] rV rg r` Z NLCRE_crackrT rX NLobjectr r
r r r r r r s(
[ PK ! e2 ' __pycache__/errors.cpython-36.opt-1.pycnu [ 3
Ii @ s d Z G dd deZG dd deZG dd deZG dd deZG d d
d
eeZG d d d eZG d
d deZ G dd de
Z G dd de Z G dd de Z
G dd de ZG dd de ZG dd de ZG dd d e ZeZG d d d e ZG d d d e ZG d!d" d"e ZG d#d$ d$e ZG d%d& d&e ZG d'd( d(e ZG d)d* d*e ZG d+d, d,eZG d-d. d.eZG d/d0 d0eZ G d1d2 d2eZ G d3d4 d4eZ d5S )6z email package exception classes.c @ s e Zd ZdZdS ) MessageErrorz+Base class for errors in the email package.N)__name__
__module__ __qualname____doc__ r r $/usr/lib64/python3.6/email/errors.pyr s r c @ s e Zd ZdZdS )MessageParseErrorz&Base class for message parsing errors.N)r r r r r r r r r s r c @ s e Zd ZdZdS )HeaderParseErrorz Error while parsing headers.N)r r r r r r r r r s r c @ s e Zd ZdZdS )
BoundaryErrorz#Couldn't find terminating boundary.N)r r r r r r r r r
s r
c @ s e Zd ZdZdS )MultipartConversionErrorz(Conversion to a multipart is prohibited.N)r r r r r r r r r s r c @ s e Zd ZdZdS ) CharsetErrorz An illegal charset was given.N)r r r r r r r r r s r c @ s e Zd ZdZdS )HeaderWriteErrorz Error while writing headers.N)r r r r r r r r r
s r
c s" e Zd ZdZd fdd Z ZS )
MessageDefectz Base class for a message defect.Nc s |d k rt j| || _d S )N)super__init__line)selfr ) __class__r r r ( s zMessageDefect.__init__)N)r r r r r
__classcell__r r )r r r % s r c @ s e Zd ZdZdS )NoBoundaryInMultipartDefectzBA message claimed to be a multipart but had no boundary parameter.N)r r r r r r r r r - s r c @ s e Zd ZdZdS )StartBoundaryNotFoundDefectz+The claimed start boundary was never found.N)r r r r r r r r r 0 s r c @ s e Zd ZdZdS )CloseBoundaryNotFoundDefectzEA start boundary was found, but not the corresponding close boundary.N)r r r r r r r r r 3 s r c @ s e Zd ZdZdS )#FirstHeaderLineIsContinuationDefectz;A message had a continuation line as its first header line.N)r r r r r r r r r 6 s r c @ s e Zd ZdZdS ) MisplacedEnvelopeHeaderDefectz?A 'Unix-from' header was found in the middle of a header block.N)r r r r r r r r r 9 s r c @ s e Zd ZdZdS ) MissingHeaderBodySeparatorDefectzEFound line with no leading whitespace and no colon before blank line.N)r r r r r r r r r < s r c @ s e Zd ZdZdS )!MultipartInvariantViolationDefectz?A message claimed to be a multipart but no subparts were found.N)r r r r r r r r r A s r c @ s e Zd ZdZdS )-InvalidMultipartContentTransferEncodingDefectzEAn invalid content transfer encoding was set on the multipart itself.N)r r r r r r r r r D s r c @ s e Zd ZdZdS )UndecodableBytesDefectz0Header contained bytes that could not be decodedN)r r r r r r r r r G s r c @ s e Zd ZdZdS )InvalidBase64PaddingDefectz/base64 encoded sequence had an incorrect lengthN)r r r r r r r r r J s r c @ s e Zd ZdZdS ) InvalidBase64CharactersDefectz=base64 encoded sequence had characters not in base64 alphabetN)r r r r r r r r r M s r c @ s e Zd ZdZdS )InvalidBase64LengthDefectz4base64 encoded sequence had invalid length (1 mod 4)N)r r r r r r r r r P s r c s e Zd ZdZ fddZ ZS ) HeaderDefectz Base class for a header defect.c s t j|| d S )N)r r )r argskw)r r r r X s zHeaderDefect.__init__)r r r r r r r r )r r r! U s r! c @ s e Zd ZdZdS )InvalidHeaderDefectz+Header is not valid, message gives details.N)r r r r r r r r r$ [ s r$ c @ s e Zd ZdZdS )HeaderMissingRequiredValuez(A header that must have a value had noneN)r r r r r r r r r% ^ s r% c s( e Zd ZdZ fddZdd Z ZS )NonPrintableDefectz8ASCII characters outside the ascii-printable range foundc s t j| || _d S )N)r r non_printables)r r' )r r r r d s zNonPrintableDefect.__init__c C s dj | jS )Nz6the following ASCII non-printables found in header: {})formatr' )r r r r __str__h s zNonPrintableDefect.__str__)r r r r r r) r r r )r r r& a s r& c @ s e Zd ZdZdS )ObsoleteHeaderDefectz0Header uses syntax declared obsolete by RFC 5322N)r r r r r r r r r* l s r* c @ s e Zd ZdZdS )NonASCIILocalPartDefectz(local_part contains non-ASCII charactersN)r r r r r r r r r+ o s r+ N) r Exceptionr r r r
TypeErrorr r r
ValueErrorr r r r r r r ZMalformedHeaderDefectr r r r r r r! r$ r% r& r* r+ r r r r s6 PK ! Nx x * __pycache__/iterators.cpython-36.opt-1.pycnu [ 3
\W @ sL d Z dddgZddlZddlmZ dd Zdd dZdd dZdd d
ZdS )z1Various types of useful iterators and generators.body_line_iteratortyped_subpart_iteratorwalk N)StringIOc c s2 | V | j r.x | j D ]}|j E dH qW dS )zWalk over the message tree, yielding each subpart.
The walk is performed in depth-first order. This method is a
generator.
N) is_multipart get_payloadr )selfsubpart r
'/usr/lib64/python3.6/email/iterators.pyr s Fc c s: x4| j D ](}|j|d}t|tr
t|E dH q
W dS )zIterate over the parts, returning string payloads line-by-line.
Optional decode (default False) is passed through to .get_payload().
)decodeN)r r
isinstancestrr )msgr r Zpayloadr
r
r r " s
textc c s< x6| j D ]*}|j |kr
|dks.|j |kr
|V q
W dS )zIterate over the subparts with a given MIME type.
Use `maintype' as the main MIME type to match against; this defaults to
"text". Optional `subtype' is the MIME subtype to match against; if
omitted, only the main type is matched.
N)r Zget_content_maintypeZget_content_subtype)r Zmaintypesubtyper r
r
r r - s c C s |dkrt j}d|d }t|| j d|d |rJtd| j |d n
t|d | j rx"| j D ]}t|||d | qfW dS ) zA handy debugging aidN )endfilez [%s])r )sysstdoutprintZget_content_typeZget_default_typer r
_structure)r fplevelZinclude_defaultZtabr r
r
r r ; s
r )F)r N)Nr F) __doc____all__r ior r r r r r
r
r
r s
PK ! R + __pycache__/base64mime.cpython-36.opt-1.pycnu [ 3
\
@ st d Z ddddddgZddlmZ dd lmZmZ d
Zd Zd Z d
Z
dd Z dddZ defddZ
dd ZeZeZdS )a Base64 content transfer encoding per RFCs 2045-2047.
This module handles the content transfer encoding method defined in RFC 2045
to encode arbitrary 8-bit data using the three 8-bit bytes in four 7-bit
characters encoding known as Base64.
It is used in the MIME standards for email to attach images, audio, and text
using some 8-bit character sets to messages.
This module provides an interface to encode and decode both headers and bodies
with Base64 encoding.
RFC 2045 defines a method for including character set information in an
`encoded-word' in a header. This method is commonly used for 8-bit real names
in To:, From:, Cc:, etc. fields, as well as Subject: lines.
This module does not do the line wrapping or end-of-line character conversion
necessary for proper internationalized headers; it only does dumb encoding and
decoding. To deal with the various line wrapping issues, use the email.header
module.
body_decode body_encodedecode decodestring
header_encode
header_length ) b64encode)
b2a_base64
a2b_base64z
c C s* t t| d\}}|d }|r&|d7 }|S )z6Return the length of s when it is encoded with base64. )divmodlen) bytearrayZ groups_of_3Zleftovern r (/usr/lib64/python3.6/email/base64mime.pyr 2 s
iso-8859-1c C s6 | sdS t | tr | j|} t| jd}d||f S )zEncode a single header line with Base64 encoding in a given charset.
charset names the character set to use to encode the header. It defaults
to iso-8859-1. Base64 encoding is defined in RFC 2045.
r asciiz =?%s?b?%s?=)
isinstancestrencoder r )Z header_bytescharsetZencodedr r r r = s
L c C s | s| S g }|d d }x^t dt| |D ]J}t| ||| jd}|jtrj|tkrj|dd | }|j| q*W tj|S )a1 Encode a string with base64.
Each line will be wrapped at, at most, maxlinelen characters (defaults to
76 characters).
Each line of encoded text will end with eol, which defaults to "\n". Set
this to "\r\n" if you will be using the result of this function directly
in an email.
r r r r N ) ranger r r endswithNLappend EMPTYSTRINGjoin)sZ
maxlinelenZeolZencvecZ
max_unencodediencr r r r L s
c C s. | s
t S t| tr"t| jdS t| S dS )zDecode a raw base64 string, returning a bytes object.
This function does not parse a full MIME header value encoded with
base64 (like =?iso-8859-1?b?bmloISBuaWgh?=) -- please use the high
level email.header class for that functionality.
zraw-unicode-escapeN)bytesr r r
r )stringr r r r f s
N)r )__doc____all__base64r Zbinasciir r
ZCRLFr! r# ZMISC_LENr r r r r r r r r r s$
PK ! P"& & ) __pycache__/__init__.cpython-36.opt-2.pycnu [ 3
\ @ sJ d ddddddddd d
d d d
dddgZ dd Zdd Zdd Zdd
ZdS )Z
base64mimecharsetZencoderserrorsZ
feedparser generatorheaderZ iteratorsmessagemessage_from_filemessage_from_binary_filemessage_from_stringmessage_from_bytesZmimeparserZ
quoprimimeZutilsc O s ddl m} |||j| S )N )Parser) email.parserr Zparsestr)sargskwsr r &/usr/lib64/python3.6/email/__init__.pyr s c O s ddl m} |||j| S )Nr ) BytesParser)r
r Z
parsebytes)r r r r r r r r ( s c O s ddl m} |||j| S )Nr )r )r
r parse)fpr r r r r r r 0 s c O s ddl m} |||j| S )Nr )r )r
r r )r r r r r r r r 8 s N)__all__r r r r r r r r s( PK ! y ) __pycache__/_encoded_words.cpython-36.pycnu [ 3
\F! @ s d Z ddlZddlZddlZddlZddlmZmZ ddlm Z ddddd d
d d gZ
ej ej d
j
dd Zdd ZG dd deZe Zdeed< dd Zdd Zdd Zdd Zdd
ZeedZdd ZeedZeedZ d d d Z dS ) z Routines for manipulating RFC2047 encoded words.
This is currently a package-private API, but will be considered for promotion
to a public API if there is demand.
N)
ascii_lettersdigits)errorsdecode_qencode_qdecode_bencode_blen_qlen_bdecodeencodes =([a-fA-F0-9]{2})c C s t t| jddgS )N )bytesintgroup)m r ,/usr/lib64/python3.6/email/_encoded_words.pyA s r c C s | j dd} t| g fS )N _ )replace_q_byte_subber)encodedr r r r C s c @ s, e Zd Zdejd ejd Zdd ZdS ) _QByteMaps -!*+/asciic C s. || j krt|| |< ndj|| |< | | S )Nz={:02X})safechrformat)selfkeyr r r __missing__M s
z_QByteMap.__missing__N)__name__
__module__ __qualname__r r r r r" r r r r r I s r _ c C s dj dd | D S )N c s s | ]}t | V qd S )N) _q_byte_map).0xr r r Z s zencode_q..)join)bstringr r r r Y s c C s t dd | D S )Nc s s | ]}t t| V qd S )N)lenr) )r* r+ r r r r, ] s zlen_q..)sum)r. r r r r \ s c C s t | d }|r dd d| nd}y$tj| | dd|rDtj gng fS tjk
r ytj| ddtj gfS tjk
r y"tj| d ddtj tj gfS tjk
r | tj gfS X Y nX Y nX d S )N s === T)ZvalidateFs ==) r/ base64Z b64decoder ZInvalidBase64PaddingDefectbinasciiErrorZ InvalidBase64CharactersDefectZInvalidBase64LengthDefect)r Zpad_errZmissing_paddingr r r r d s c C s t j| jdS )Nr )r3 Z b64encoder )r. r r r r s c C s& t t| d\}}|d |r dnd S )N r1 r )divmodr/ )r. Z groups_of_3Zleftoverr r r r
s )qbc C s | j d\}}}}}|jd\}}}|j }|jdd}t| |\}}y|j|}W nv tk
r |jtj dj
| |j|d}Y nB t k
r |jdd}|j dkr|jtj dj
| Y nX ||||fS )a Decode encoded word and return (string, charset, lang, defects) tuple.
An RFC 2047/2243 encoded word has the form:
=?charset*lang?cte?encoded_string?=
where '*lang' may be omitted but the other parts may not be.
This function expects exactly such a string (that is, it does not check the
syntax and may raise errors if the string is not well formed), and returns
the encoded_string decoded first from its Content Transfer Encoding and
then from the resulting bytes into unicode using the specified charset. If
the cte-decoded string does not successfully decode using the specified
character set, a defect is added to the defects list and the unknown octets
are replaced by the unicode 'unknown' character \uFDFF.
The specified charset and language are returned. The default for language,
which is rarely if ever encountered, is the empty string.
?*r surrogateescapez:Encoded word contains bytes not decodable using {} charsetz unknown-8bitz sB $
&+PK ! ˫Q_ _ ' __pycache__/parser.cpython-36.opt-1.pycnu [ 3
\ @ s d Z ddddddgZddlmZmZ dd lmZmZ dd
lm Z G d d dZ
G d d de
Z G d
d dZ G dd de Z
dS )z-A parser of RFC 2822 and MIME email messages.Parser HeaderParser BytesParserBytesHeaderParser
FeedParserBytesFeedParser )StringIO
TextIOWrapper)r r )compat32c @ s0 e Zd Zd
edddZd ddZd dd ZdS )
r N)policyc C s || _ || _dS )a Parser of RFC 2822 and MIME email messages.
Creates an in-memory object tree representing the email message, which
can then be manipulated and turned over to a Generator to return the
textual representation of the message.
The string must be formatted as a block of RFC 2822 headers and header
continuation lines, optionally preceded by a `Unix-from' header. The
header block is terminated either by the end of the string or by a
blank line.
_class is the class to instantiate for new message objects when they
must be created. This class must have a constructor that can take
zero arguments. Default is Message.Message.
The policy keyword specifies a policy object that controls a number of
aspects of the parser's operation. The default policy maintains
backward compatibility.
N)_classr )selfr r r $/usr/lib64/python3.6/email/parser.py__init__ s zParser.__init__Fc C sD t | j| jd}|r |j x |jd}|s.P |j| q W |j S )a\ Create a message structure from the data in a file.
Reads all the data from the file and returns the root of the message
structure. Optional headersonly is a flag specifying whether to stop
parsing after reading the headers or not. The default is False,
meaning it parses the entire contents of the file.
)r i )r r r Z_set_headersonlyreadZfeedclose)r
fp headersonlyZ
feedparserdatar r r parse* s
z Parser.parsec C s | j t||dS )a- Create a message structure from a string.
Returns the root of the message structure. Optional headersonly is a
flag specifying whether to stop parsing after reading the headers or
not. The default is False, meaning it parses the entire contents of
the file.
)r )r r )r
textr r r r parsestr< s zParser.parsestr)N)F)F)__name__
__module__ __qualname__r
r r r r r r r r s
c @ s e Zd ZdddZdddZdS ) r Tc C s t j| |dS )NT)r r )r
r r r r r r I s zHeaderParser.parsec C s t j| |dS )NT)r r )r
r r r r r r L s zHeaderParser.parsestrN)T)T)r r r r r r r r r r H s
c @ s( e Zd Zdd Zd ddZd
ddZdS ) r c O s t ||| _dS )a Parser of binary RFC 2822 and MIME email messages.
Creates an in-memory object tree representing the email message, which
can then be manipulated and turned over to a Generator to return the
textual representation of the message.
The input must be formatted as a block of RFC 2822 headers and header
continuation lines, optionally preceded by a `Unix-from' header. The
header block is terminated either by the end of the input or by a
blank line.
_class is the class to instantiate for new message objects when they
must be created. This class must have a constructor that can take
zero arguments. Default is Message.Message.
N)r parser)r
argskwr r r r R s zBytesParser.__init__Fc
C s, t |ddd}z| jj||S |j X dS )ac Create a message structure from the data in a binary file.
Reads all the data from the file and returns the root of the message
structure. Optional headersonly is a flag specifying whether to stop
parsing after reading the headers or not. The default is False,
meaning it parses the entire contents of the file.
asciisurrogateescape)encodingerrorsN)r r r detach)r
r r r r r r d s zBytesParser.parsec C s |j ddd}| jj||S )a2 Create a message structure from a byte string.
Returns the root of the message structure. Optional headersonly is a
flag specifying whether to stop parsing after reading the headers or
not. The default is False, meaning it parses the entire contents of
the file.
ASCIIr )r" )decoder r )r
r r r r r
parsebytess s zBytesParser.parsebytesN)F)F)r r r r r r& r r r r r P s
c @ s e Zd ZdddZdddZdS ) r Tc C s t j| |ddS )NT)r )r r )r
r r r r r r s zBytesHeaderParser.parsec C s t j| |ddS )NT)r )r r& )r
r r r r r r& s z BytesHeaderParser.parsebytesN)T)T)r r r r r& r r r r r s
N)__doc____all__ior r Zemail.feedparserr r Zemail._policybaser
r r r r r r r r s 7/PK ! b@ b@ ' __pycache__/header.cpython-36.opt-1.pycnu [ 3
\&^ @ s d Z dddgZddlZddlZddlZddlZddlmZ ddlm Z
e
j Z dZ d Z
d
ZdZd Zd
ZdZe dZe dZejdejejB ejB ZejdZejdZej j Z dd Z d ddZ G dd dZ G dd dZ!G dd de"Z#dS ) z+Header encoding and decoding functionality.Header
decode_header make_header N)HeaderParseError)charset
N z zus-asciizutf-8ai
=\? # literal =?
(?P[^?]*?) # non-greedy up to the next ? is the charset
\? # literal ?
(?P[qb]) # either a "q" or a "b", case insensitive
\? # literal ?
(?P.*?) # non-greedy up to the next ?= is the encoded string
\?= # literal ?=
z[\041-\176]+:$z
\n[^ \t]+:c C s t | drdd | jD S tj| s.| dfgS g }x| j D ]}tj|}d}xp|r|jd}|rn|j }d}|r|j|ddf |rP|jdj }|jdj }|jd}|j|||f qPW qM s z!decode_header..NTr F qb z===zBase64 decoding errorzUnexpected encoding: zraw-unicode-escape)hasattrr
ecresearch
splitlinessplitpoplstripappendlower enumerateisspacereversedemail
quoprimimeZ
header_decodelenZ
base64mimedecodebinasciiErrorr AssertionError
isinstancer bytesBSPACE)headerZwordslinepartsfirstZ unencodedr encodingZencodedZdroplistnwdZ
decoded_wordsZencoded_stringZwordZpaderrZ collapsedZ last_word last_charsetr r r r = sz
4
c C sL t |||d}x8| D ]0\}}|dk r8t|t r8t|}|j|| qW |S )a Create a Header from a sequence of pairs as returned by decode_header()
decode_header() takes a header value string and returns a sequence of
pairs of the format (decoded_string, charset) where charset is the string
name of the character set.
This function takes one of those sequence of pairs and returns a Header
instance. Optional maxlinelen, header_name, and continuation_ws are as in
the Header constructor.
)
maxlinelen header_namecontinuation_wsN)r r- Charsetr! )Z decoded_seqr9 r: r; hsr r r r r s c @ sJ e Zd ZdddZdd Zdd Zdd
d Zd d
ZdddZdd Z dS )r Nr strictc C s| |dkrt }nt|ts t|}|| _|| _g | _|dk rH| j||| |dkrTt}|| _|dkrjd| _ nt
|d | _ dS )aD Create a MIME-compliant header that can contain many character sets.
Optional s is the initial header value. If None, the initial header
value is not set. You can later append to the header with .append()
method calls. s may be a byte string or a Unicode string, but see the
.append() documentation for semantics.
Optional charset serves two purposes: it has the same meaning as the
charset argument to the .append() method. It also sets the default
character set for all subsequent .append() calls that omit the charset
argument. If charset is not provided in the constructor, the us-ascii
charset is used both as s's initial charset and as the default for
subsequent .append() calls.
The maximum line length can be specified explicitly via maxlinelen. For
splitting the first line to a shorter value (to account for the field
header which isn't included in s, e.g. `Subject') pass in the name of
the field in header_name. The default maxlinelen is 78 as recommended
by RFC 2822.
continuation_ws must be RFC 2822 compliant folding whitespace (usually
either a space or a hard tab) which will be prepended to continuation
lines.
errors is passed through to the .append() call.
Nr r ) USASCIIr- r< r _continuation_wsr
r!
MAXLINELEN _maxlinelen
_headerlenr( )selfr> r r9 r: r; errorsr r r __init__ s
zHeader.__init__c C s | j g }d}d}x| jD ]\}}|}|tjkrJ|jdd}|jdd}|r|o^| j|d }|dkr|d kr| r|jt d}n|d
kr| r|jt |o| j|d }|}|j| q W t j
|S ) z&Return the string value of the header.Nasciisurrogateescapereplacer us-asciir )NrK )NrK )NrK )
_normalizer
r UNKNOWN8BITencoder) _nonctextr! SPACE EMPTYSTRINGjoin) rE Zuchunkslastcs lastspacer r ZnextcsZoriginal_byteshasspacer r r __str__ s*
zHeader.__str__c C s |t | kS )N)r )rE otherr r r __eq__ s z
Header.__eq__c C s |dkr| j }nt|ts"t|}t|tsZ|jp4d}|t jkrN|jdd}n |j||}|jpbd}|t jkry|j|| W n" t k
r |dkr t
}Y nX | j j ||f dS )a. Append a string to the MIME header.
Optional charset, if given, should be a Charset instance or the name
of a character set (which will be converted to a Charset instance). A
value of None (the default) means that the charset given in the
constructor is used.
s may be a byte string or a Unicode string. If it is a byte string
(i.e. isinstance(s, str) is false), then charset is the encoding of
that byte string, and a UnicodeError will be raised if the string
cannot be decoded with that charset. If s is a Unicode string, then
charset is a hint specifying the character set of the characters in
the string. In either case, when producing an RFC 2822 compliant
header using RFC 2047 rules, the string will be encoded using the
output codec of the charset. If the string cannot be encoded to the
output codec, a UnicodeError will be raised.
Optional `errors' is passed as the errors argument to the decode
call if s is a byte string.
Nzus-asciirI )
r r- r< r Z input_codecrN r) Z output_codecrO UnicodeEncodeErrorUTF8r
r! )rE r> r rF Z
input_charsetZoutput_charsetr r r r! s$
z
Header.appendc C s |j p|dkS )z=True if string s is not a ctext character of RFC822.
()\)r\ r] r^ )r$ )rE r> r r r rP 4 s zHeader._nonctext;, r c C s | j |dkr| j}|dkr"d}t| j|| j|}d}d }}x4| jD ](\}} |dk r|ol| j|d }|d
kr| s| d kr|j n| d kr| r|j |o| j|d
}| }d}|j }
|
r|j d|
d | n|j dd| xr|
dd D ]b} |j
| j dk r,|j | jd| j | n.| j } | dt
| t
| }
|j |
| | qW t
|
dkrJ|j
qJW | jr|j |j|}tj|rtd j||S )a Encode a message header into an RFC-compliant format.
There are many issues involved in converting a given string for use in
an email header. Only certain character sets are readable in most
email clients, and as header strings can only contain a subset of
7-bit ASCII, care must be taken to properly convert and encode (with
Base64 or quoted-printable) header strings. In addition, there is a
75-character length limit on any given encoded header field, so
line-wrapping must be performed, even with double-byte character sets.
Optional maxlinelen specifies the maximum length of each generated
line, exclusive of the linesep string. Individual lines may be longer
than maxlinelen if a folding point cannot be found. The first line
will be shorter by the length of the header name plus ": " if a header
name was specified at Header construction time. The default value for
maxlinelen is determined at header construction time.
Optional splitchars is a string containing characters which should be
given extra weight by the splitting algorithm during normal header
wrapping. This is in very rough support of RFC 2822's `higher level
syntactic breaks': split points preceded by a splitchar are preferred
during line splitting, with the characters preferred in the order in
which they appear in the string. Space and tab may be included in the
string to indicate whether preference should be given to one over the
other as a split point when other split chars do not appear in the line
being split. Splitchars does not affect RFC 2047 encoded lines.
Optional linesep is a string to be used to separate the lines of
the value. The default value is the most useful for typical
Python applications, but it can be set to \r\n to produce RFC-compliant
line separators when needed.
Nr i@B us-asciir Fr r z8header value appears to contain an embedded header: {!r})Nr` )Nr` )Nr` rL )rM rC _ValueFormatterrD rA r
rP add_transitionr feednewlineheader_encodingr r( _str_embedded_headerr r format)rE
splitcharsr9 linesepZ formatterrT rV rU r r linesr1 Zslinefwsvaluer r r rO 9 sR !
z
Header.encodec C s| g }d }g }xL| j D ]B\}}||kr0|j| q|d k rL|jtj||f |g}|}qW |rr|jtj||f || _ d S )N)r
r! rQ rS )rE Zchunksr8 Z
last_chunkr r r r r rM s zHeader._normalize)NNNNr r? )Nr? )r_ Nr )
__name__
__module__ __qualname__rG rW rY r! rP rO rM r r r r r s
-
+
Pc @ sT e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dS )ra c C s0 || _ || _t|| _|| _g | _t|| _d S )N)_maxlenrA r( _continuation_ws_len _splitchars_lines _Accumulator
_current_line)rE Z headerlenmaxlenr; ri r r r rG s
z_ValueFormatter.__init__c C s | j |j| jS )N)rd rS rt )rE rj r r r rf s z_ValueFormatter._strc C s
| j tS )N)rf NL)rE r r r rW s z_ValueFormatter.__str__c C sp | j j }|dkr | j j| t| j dkrb| j j rP| jd t| j 7 < n| jjt| j | j j d S )Nr r r r )r r rL ) rv r pushr( is_onlywsrt r r! reset)rE Z end_of_liner r r rd s
z_ValueFormatter.newlinec C s | j jdd d S )Nr r )rv ry )rE r r r rb s z _ValueFormatter.add_transitionc C s |j d kr | j||| j d S |j|| j }y|jd}W n tk
rP d S X |d k rf| j|| y |j }W n tk
r d S X | j | j j
| j | x |D ]}| j j
| j | qW d S )Nr )re _ascii_splitrs Zheader_encode_lines _maxlengthsr
IndexError
_append_chunkrd rv ry rA rt r! )rE rl r r Z
encoded_linesZ
first_line last_liner1 r r r rc s$
z_ValueFormatter.feedc c s* | j t| j V x| j | j V qW d S )N)rq r( rv rr )rE r r r r} s z_ValueFormatter._maxlengthsc C sj t jdt d || }|d r0dg|d d< n
|jd x*tt|gd D ]\}}| j|| qNW d S )Nz([z]+)r r r )rer FWSr zipiterr )rE rl r ri r2 partr r r r| s
z _ValueFormatter._ascii_splitc C s
| j j|| t| j | jkrx| jD ]t}xlt| j j d ddD ]P}|j rp| j | d }|rp|d |krpP | j |d d }|rD|d |krDP qDW q(P q(W | j j \}}| j j dkr| j
|sd}| j j|| d S | j j |}| j j
t| j | j j| d S )Nr r r rL rL )rv ry r( rq rs range
part_countr$ r
_initial_sizerd pop_fromrt r! r r{ )rE rl r ZchiZprevpartr Z remainderr r r r s. z _ValueFormatter._append_chunkN) rn ro rp rG rf rW rd rb rc r} r| r r r r r ra s %ra c sj e Zd Zd fdd Zdd ZdddZ fdd Zd
d Zd d
ZdddZ dd Z
fddZ Z S )ru r c s || _ t j d S )N)r superrG )rE Z initial_size) __class__r r rG s z_Accumulator.__init__c C s | j ||f d S )N)r! )rE rl r r r r ry # s z_Accumulator.pushc C s | |d }g | |d < |S )Nr )rE r Zpoppedr r r r & s z_Accumulator.pop_fromc s | j dkrdS t j S )Nr r )r r )r r r )rE )r r r r + s z_Accumulator.popc C s t dd | D | jS )Nc s s" | ]\}}t |t | V qd S )N)r( )r rl r r r r 1 s z'_Accumulator.__len__..)sumr )rE r r r __len__0 s z_Accumulator.__len__c C s t jdd | D S )Nc s s | ]\}}t j||fV qd S )N)rR rS )r rl r r r r r 5 s z'_Accumulator.__str__..)rR rS )rE r r r rW 4 s
z_Accumulator.__str__Nc C s" |d kr g }|| d d < d| _ d S )Nr )r )rE Zstartvalr r r r{ 8 s z_Accumulator.resetc C s | j dko| pt| j S )Nr )r r r$ )rE r r r rz > s z_Accumulator.is_onlywsc s
t j S )N)r r )rE )r r r r A s z_Accumulator.part_count)r )r )N)
rn ro rp rG ry r r r rW r{ rz r
__classcell__r r )r r ru s
ru z )NNr )$__doc____all__r r* Zemail.quoprimimer& Zemail.base64mimeZ email.errorsr r r r< rx rQ r/ ZSPACE8rR rB r r@ r[ compileVERBOSE
IGNORECASE MULTILINEr Zfcrerg r' Z _max_appendr r r ra listru r r r r s@
_
k PK ! Aj j ) __pycache__/encoders.cpython-36.opt-1.pycnu [ 3
\ @ sT d Z ddddgZddlmZ ddlmZ dd Zd
d Z d d Z
d d Z d
d Z dS )z Encodings and related functions.encode_7or8bit
encode_base64 encode_noop
encode_quopri ) encodebytes) encodestringc C s t | dd}|jddS )NT)Z quotetabs s =20)
_encodestringreplace)senc r
&/usr/lib64/python3.6/email/encoders.py_qencode s r c C s0 | j dd}tt|d}| j| d| d< dS )zlEncode the message's payload in Base64.
Also, add an appropriate Content-Transfer-Encoding header.
T)decodeasciibase64zContent-Transfer-EncodingN) get_payloadstr_bencode set_payload)msgorigencdatar
r
r r s
c C s* | j dd}t|}| j| d| d< dS )zvEncode the message's payload in quoted-printable.
Also, add an appropriate Content-Transfer-Encoding header.
T)r zquoted-printablezContent-Transfer-EncodingN)r r r )r r r r
r
r r & s
c C sX | j dd}|dkr d| d< dS y|jd W n tk
rJ d| d< Y n
X d| d< dS )z9Set the Content-Transfer-Encoding header to 7bit or 8bit.T)r NZ7bitzContent-Transfer-Encodingr Z8bit)r r UnicodeError)r r r
r
r r 2 s c C s dS )z Do nothing.Nr
)r r
r
r r D s N)
__doc____all__r r r quoprir r r r r r r r
r
r
r s PK ! pC% C% + __pycache__/_parseaddr.cpython-36.opt-2.pycnu [ 3
IiD @ s d dddgZ ddlZddlZdZdZdZd d
d d d
dddddddddddd
dddd d d d gZd d!d"d#d$d%d&gZddddd8d9d:d;dd?d@dAd-Zd.d Z d/d0 Z
d1d Z d2d Z d3d Z
G d4d5 d5ZG d6d7 d7eZdS )B mktime_tz parsedate parsedate_tzquote N z, ZjanZfebZmarZaprZmayZjunZjulZaugsepoctZnovZdecZjanuaryZfebruaryZmarchZaprilZjuneZjulyZaugustZ septemberZoctoberZnovemberZdecemberZmonZtueZwedZthuZfriZsatZsuni i, i iX i i )ZUTZUTCZGMTZZASTZADTZESTZEDTZCSTZCDTZMSTZMDTZPSTZPDTc C s, t | }|sd S |d d kr$d|d< t|S )N r )
_parsedate_tztuple)datares r (/usr/lib64/python3.6/email/_parseaddr.pyr - s c C s | sd S | j } | d jds.| d j tkr6| d= n.| d jd}|dkrd| d |d d | d< t| dkr| d j d}t|dkr|| dd } t| dkr | d }|jd}|dkr|jd}|dkr|d | ||d g| dd < n
| jd t| d k rd S | d d } | \}}}}}|j }|tkrZ||j }}|tkrZd S tj |d }|d
krz|d
8 }|d dkr|d d }|jd }|dkr|| }}|d dkr|d d }|d j
s|| }}|d dkr|d d }|j d }t|d kr$|\} }
d
} n~t|dkr>|\} }
} ndt|dkrd|d kr|d j d}t|d kr|\} }
d} nt|dkr|\} }
} nd S y,t |}t |}t | } t |
}
t | } W n t k
r d S X |dk r |dkr|d7 }n|d7 }d } |j
}|tkr,t| } n>y t |} W n t k
rN Y nX | dkrj|jdrjd } | r| dk rd }
| } nd}
|
| d d | d d } |||| |
| ddd | g
S ) Nr , - +r : 0.d D il i i < r! r! r! r! r! r! r! r! )splitendswithlower _daynamesrfindlenfindappend _monthnamesindexisdigitint
ValueErrorupper
_timezones
startswith)r iZstuffsZddZmmZyyZtmZtzZthhZtmmZtssZtzoffsetZtzsignr r r r 9 s
"
r c C s& t | }t|tr |d d S |S d S )Nr )r
isinstancer
)r tr r r r s
c C s< | d d kr"t j| d d d S tj| }|| d S d S )Nr r r! )r! )timeZmktimecalendarZtimegm)r r5 r r r r s
c C s | j ddj ddS )N\z\\"z\")replace)strr r r r s c @ sx e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z d ddZ
dd Z dd Z dd Z
d ddZdd ZdS )
AddrlistClassc C sZ d| _ d| _d| _d| _| j| j | _| j | j | j | _| jjdd| _|| _g | _ d S )Nz ()<>@,:;."[]r z z
r r )
specialsposLWSZCRFWSatomendsr;
phraseendsfield commentlist)selfrD r r r __init__ s zAddrlistClass.__init__c C s g }x| j t| jk r| j| j | jd kr^| j| j dkrN|j| j| j | j d7 _ q| j| j dkr| jj| j qP qW tj|S )Nz
r () r? r' rD r@ r) rE
getcomment EMPTYSTRINGjoin)rF Zwslistr r r gotonext s zAddrlistClass.gotonextc C s> g }x4| j t| jk r8| j }|r,||7 }q|jd qW |S )Nr )r r )r? r' rD
getaddressr) )rF resultZadr r r getaddrlist s
zAddrlistClass.getaddrlistc C s g | _ | j | j}| j }| j }| j g }| jt| jkr\|rXtj| j |d fg}n\| j| j dkr|| _|| _ | j }tj| j |fg}n"| j| j dkr g }t| j}| jd7 _x| jt| jk r| j | j|k o| j| j dkr | jd7 _P || j }qW n| j| j dkrx| j
}| j rftj|d dj| j d |fg}ntj||fg}n@|rtj| j |d fg}n"| j| j | j kr| jd7 _| j | jt| jk r| j| j d
kr| jd7 _|S ) Nr z.@r r ; )rF ZoldposZoldclplistZ
returnlistZaddrspecZfieldlenZ routeaddrr r r rM sL
&$zAddrlistClass.getaddressc C s | j | j dkrd S d}| jd7 _| j d}x| jt| j k r|rV| j d}n~| j | j dkrx| jd7 _P n\| j | j dkr| jd7 _d}n8| j | j dkr| jd7 _n| j }| jd7 _P | j q4W |S ) NrQ Fr r >@Tr )rD r? rL r' getdomainrU )rF Z expectrouteZadlistr r r rV ? s. zAddrlistClass.getrouteaddrc C s\ g }| j x| jt| jk rd}| j| j dkrj|rL|d j rL|j |jd | jd7 _d}nf| j| j dkr|jdt| j n>| j| j | j kr|r|d j r|j P n|j| j
| j }|r|r|j| qW | jt| jks| j| j dkr t j |S |jd | jd7 _| j | j
}|sNt S t j || S )
NTr r Fr: z"%s"rY r! r! )rL r? r' rD strippopr) r getquoterB getatomrJ rK rZ )rF ZaslistZ preserve_wsZwsZdomainr r r rU _ s:
$
zAddrlistClass.getaddrspecc C s g }x| j t| jk r| j| j | jkr8| j d7 _ q| j| j dkrZ| jj| j q| j| j dkrz|j| j q| j| j dkr| j d7 _ |jd q| j| j dkrtS | j| j | j krP q|j| j
qW tj |S )Nr rH [r rY ) r? r' rD r@ rE r) rI getdomainliteralrJ rB r^ rK )rF Zsdlistr r r rZ s" zAddrlistClass.getdomainTc C s | j | j |krdS dg}d}| jd7 _x| jt| j k r|rZ|j| j | j d}np| j | j |kr|| jd7 _P nN|r| j | j dkr|j| j q.n(| j | j dkrd}n|j| j | j | jd7 _q.W tj|S )Nr Fr rH r9 T)rD r? r' r) rI rJ rK )rF Z begincharZendcharsZ
allowcommentsZslistr r r r getdelimited s(
zAddrlistClass.getdelimitedc C s | j dddS )Nr: z"
F)ra )rF r r r r] s zAddrlistClass.getquotec C s | j dddS )NrH z)
T)ra )rF r r r rI s zAddrlistClass.getcommentc C s d| j ddd S )Nz[%s]r_ z]
F)ra )rF r r r r` s z AddrlistClass.getdomainliteralNc C sh dg}|d kr| j }xH| jt| jk r\| j| j |kr:P n|j| j| j | jd7 _qW tj|S )Nr r )rB r? r' rD r) rJ rK )rF rB Zatomlistr r r r^ s zAddrlistClass.getatomc C s g }x| j t| jk r| j| j | jkr8| j d7 _ q| j| j dkrX|j| j q| j| j dkrz| jj| j q| j| j | jkrP q|j| j | j qW |S )Nr r: rH )
r? r' rD rA r) r] rE rI rC r^ )rF rW r r r rS s zAddrlistClass.getphraselist)T)N)__name__
__module__ __qualname__rG rL rO rM rV rU rZ ra r] rI r` r^ rS r r r r r= s
; &
%
r= c @ sD e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dS ) AddressListc C s& t j| | |r | j | _ng | _d S )N)r= rG rO addresslist)rF rD r r r rG s zAddressList.__init__c C s
t | jS )N)r' rf )rF r r r __len__ s zAddressList.__len__c C sB t d }| jd d |_x$|jD ]}|| jkr |jj| q W |S )N)re rf r) )rF othernewaddrxr r r __add__ s
zAddressList.__add__c C s* x$|j D ]}|| j kr| j j| qW | S )N)rf r) )rF rh rj r r r __iadd__
s
zAddressList.__iadd__c C s2 t d }x$| jD ]}||jkr|jj| qW |S )N)re rf r) )rF rh ri rj r r r __sub__ s
zAddressList.__sub__c C s* x$|j D ]}|| j kr| j j| qW | S )N)rf remove)rF rh rj r r r __isub__ s
zAddressList.__isub__c C s
| j | S )N)rf )rF r+ r r r __getitem__# s zAddressList.__getitem__N)
rb rc rd rG rg rk rl rm ro rp r r r r re s re ipii ipii iDiiiD)__all__r7 r8 rT rJ Z
COMMASPACEr* r% r0 r r r r r r= re r r r r
s6
u
/PK ! E= + __pycache__/quoprimime.cpython-36.opt-1.pycnu [ 3
\&
@ sd d Z ddddddddd d
g
Zd d lZd d
lmZmZmZ dZdZdZ dd e
dD Z e d d Z e d d Z
x,dejd ejd D ]Zeee e< qW de ed< xdD ]Zeee
e< qW dd Zdd Zd d Zd d Zd,d d Zd!d
Zd"d Zd-d$dZe
d d Zxd%D ]Zeeee< qW d&efd'dZefd(dZ e Z e Z d)d* Z d+d Z d S ).aF Quoted-printable content transfer encoding per RFCs 2045-2047.
This module handles the content transfer encoding method defined in RFC 2045
to encode US ASCII-like 8-bit data called `quoted-printable'. It is used to
safely encode text that is in a character set similar to the 7-bit US ASCII
character set, but that includes some 8-bit characters that are normally not
allowed in email bodies or headers.
Quoted-printable is very space-inefficient for encoding binary files; use the
email.base64mime module for that instead.
This module provides an interface to encode and decode both headers and bodies
with quoted-printable encoding.
RFC 2045 defines a method for including character set information in an
`encoded-word' in a header. This method is commonly used for 8-bit real names
in To:/From:/Cc: etc. fields, as well as Subject: lines.
This module does not do the line wrapping or end-of-line character
conversion necessary for proper internationalized headers; it only
does dumb encoding and decoding. To deal with the various line
wrapping issues, use the email.header module.
body_decode body_encode body_lengthdecode decodestring
header_decode
header_encode
header_lengthquoteunquote N)
ascii_lettersdigits hexdigitsz
c C s g | ] }d | qS )z=%02X ).0cr r (/usr/lib64/python3.6/email/quoprimime.py
7 s r s -!*+/ascii_ s_ !"#$%&'()*+,-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ c C s t | t| kS )z>Return True if the octet should be escaped with header quopri.)chr_QUOPRI_HEADER_MAP)octetr r r header_checkJ s r c C s t | t| kS )z^ s z header_length..)sum) bytearrayr r r r T s
c C s t dd | D S )zReturn a body quoted-printable encoding length.
:param bytearray: An array of bytes (a.k.a. octets).
:return: The length in bytes of the byte array when it is encoded with
quoted-printable for bodies.
c s s | ]}t t| V qd S )N)r r )r r r r r r! h s z body_length..)r" )r# r r r r a s c C sf t |tst|}| s&| j|j nn^|d |k r||d tkr||d tkr|t|||d 7 }|d7 }n||7 }|d7 }||kr>||7 }q>W qW | d dkr |j|r |dd
}|S ) z_Decode a quoted-printable string.
Lines are separated with eol, which defaults to \n.
r r r: r$ r; r. z
Nr% r% )r> rstripr r r
endswith)r7 rA ZdecodedrB inr r r r r s8
,
c C s | j d}t|S )zCTurn a match in the form =AB to the ASCII character with value 0xabr )groupr
)matchr+ r r r _unquote_match s
rL c C s | j dd} tjdt| tjdS )a Decode a string encoded with RFC 2045 MIME header `Q' encoding.
This function does not parse a full MIME header value encoded with
quoted-printable (like =?iso-8859-1?q?Hello_World?=) -- please use
the high level email.header class for that functionality.
r r z=[a-fA-F0-9]{2})flags)replaceresubrL ASCII)r+ r r r r # s )r )r3 )!__doc____all__rO stringr r
r r? NLZ EMPTYSTRINGranger1 r r encoder r r2 r r r r r- r
r r r= r r r r rL r r r r r sP
O 0PK ! R % __pycache__/base64mime.cpython-36.pycnu [ 3
\
@ st d Z ddddddgZddlmZ dd lmZmZ d
Zd Zd Z d
Z
dd Z dddZ defddZ
dd ZeZeZdS )a Base64 content transfer encoding per RFCs 2045-2047.
This module handles the content transfer encoding method defined in RFC 2045
to encode arbitrary 8-bit data using the three 8-bit bytes in four 7-bit
characters encoding known as Base64.
It is used in the MIME standards for email to attach images, audio, and text
using some 8-bit character sets to messages.
This module provides an interface to encode and decode both headers and bodies
with Base64 encoding.
RFC 2045 defines a method for including character set information in an
`encoded-word' in a header. This method is commonly used for 8-bit real names
in To:, From:, Cc:, etc. fields, as well as Subject: lines.
This module does not do the line wrapping or end-of-line character conversion
necessary for proper internationalized headers; it only does dumb encoding and
decoding. To deal with the various line wrapping issues, use the email.header
module.
body_decode body_encodedecode decodestring
header_encode
header_length ) b64encode)
b2a_base64
a2b_base64z
c C s* t t| d\}}|d }|r&|d7 }|S )z6Return the length of s when it is encoded with base64. )divmodlen) bytearrayZ groups_of_3Zleftovern r (/usr/lib64/python3.6/email/base64mime.pyr 2 s
iso-8859-1c C s6 | sdS t | tr | j|} t| jd}d||f S )zEncode a single header line with Base64 encoding in a given charset.
charset names the character set to use to encode the header. It defaults
to iso-8859-1. Base64 encoding is defined in RFC 2045.
r asciiz =?%s?b?%s?=)
isinstancestrencoder r )Z header_bytescharsetZencodedr r r r = s
L c C s | s| S g }|d d }x^t dt| |D ]J}t| ||| jd}|jtrj|tkrj|dd | }|j| q*W tj|S )a1 Encode a string with base64.
Each line will be wrapped at, at most, maxlinelen characters (defaults to
76 characters).
Each line of encoded text will end with eol, which defaults to "\n". Set
this to "\r\n" if you will be using the result of this function directly
in an email.
r r r r N ) ranger r r endswithNLappend EMPTYSTRINGjoin)sZ
maxlinelenZeolZencvecZ
max_unencodediencr r r r L s
c C s. | s
t S t| tr"t| jdS t| S dS )zDecode a raw base64 string, returning a bytes object.
This function does not parse a full MIME header value encoded with
base64 (like =?iso-8859-1?b?bmloISBuaWgh?=) -- please use the high
level email.header class for that functionality.
zraw-unicode-escapeN)bytesr r r
r )stringr r r r f s
N)r )__doc____all__base64r Zbinasciir r
ZCRLFr! r# ZMISC_LENr r r r r r r r r r s$
PK ! WK , __pycache__/_policybase.cpython-36.opt-2.pycnu [ 3
Ii< @ s d dl Z d dlmZ d dlmZ d dlmZ dddgZG dd d Zd
d Z d d
Z
G dd dee j dZ e
G dd de Z
e
ZdS ) N)header)charset)_has_surrogatesPolicyCompat32compat32c s< e Zd Z fddZdd Zdd Zdd Zd d
Z ZS ) _PolicyBasec sL xF|j D ]:\}}t| |r0tt| j|| q
tdj|| jjq
W d S )Nz*{!r} is an invalid keyword argument for {}) itemshasattrsuperr __setattr__ TypeErrorformat __class____name__)selfkwnamevalue)r )/usr/lib64/python3.6/email/_policybase.py__init__) s
z_PolicyBase.__init__c C s* dd | j j D }dj| jjdj|S )Nc S s g | ]\}}d j ||qS )z{}={!r})r ).0r r r r r
8 s z(_PolicyBase.__repr__..z{}({})z, )__dict__r r r r join)r argsr r r __repr__7 s z_PolicyBase.__repr__c K sz | j j| j }x$| jj D ]\}}tj||| qW x@|j D ]4\}}t| |sdtdj|| j j tj||| q>W |S )Nz*{!r} is an invalid keyword argument for {})
r __new__r r objectr r
r
r r )r r Z newpolicyattrr r r r clone< s
z_PolicyBase.clonec C s, t | |rd}nd}t|j| jj|d S )Nz'{!r} object attribute {!r} is read-onlyz!{!r} object has no attribute {!r})r
AttributeErrorr r r )r r r msgr r r r N s
z_PolicyBase.__setattr__c C s | j f |jS )N)r! r )r otherr r r __add__U s z_PolicyBase.__add__) r
__module__ __qualname__r r r! r r%
__classcell__r r )r r r s
r c C s, | j ddd } |jddd }| d | S )N
r )rsplitsplit)docZ added_docr r r _append_doc^ s r. c C s | j r(| j jdr(t| jd j | j | _ xf| jj D ]X\}}|j r4|j jdr4xh s z%_extend_docstrings..__doc__)r4
startswithr. __bases__r r getattr)clsr r r2 r- r r r _extend_docstringsc s
r9 c @ s e Zd ZdZdZdZdZdZdZdZ dd Z
d d
Z d d Z e
jd
d Ze
jdd Ze
jdd Ze
jdd Ze
jdd ZdS )r Fr) Z8bitN NTc C s | j r
|| j|| d S )N)raise_on_defectregister_defect)r objdefectr r r
handle_defect s zPolicy.handle_defectc C s |j j| d S )N)Zdefectsappend)r r= r> r r r r< s zPolicy.register_defectc C s d S )Nr )r r r r r header_max_count s zPolicy.header_max_countc C s t d S )N)NotImplementedError)r sourcelinesr r r header_source_parse s zPolicy.header_source_parsec C s t d S )N)rB )r r r r r r header_store_parse s zPolicy.header_store_parsec C s t d S )N)rB )r r r r r r header_fetch_parse s zPolicy.header_fetch_parsec C s t d S )N)rB )r r r r r r fold s
z Policy.foldc C s t d S )N)rB )r r r r r r fold_binary s zPolicy.fold_binary)r r& r' r; linesepcte_typemax_line_length mangle_from_Zmessage_factoryZverify_generated_headersr? r< rA abcabstractmethodrD rE rF rG rH r r r r r p s 9
) metaclassc @ sH e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dS )r Tc C s0 t |ts|S t|r(tj|tj|dS |S d S )N)r header_name)
isinstancestrr r Header_charset UNKNOWN8BIT)r r r r r r _sanitize_header! s
zCompat32._sanitize_headerc C s> |d j dd\}}|jddj|dd }||jdfS )Nr :r* z z
)r, lstripr rstrip)r rC r r r r r rD - s z Compat32.header_source_parsec C s ||fS )Nr )r r r r r r rE 9 s zCompat32.header_store_parsec C s | j ||S )N)rV )r r r r r r rF ? s zCompat32.header_fetch_parsec C s | j ||ddS )NT)sanitize)_fold)r r r r r r rG F s z
Compat32.foldc C s" | j ||| jdkd}|jddS )NZ7bit)r[ asciisurrogateescape)r\ rJ encode)r r r Zfoldedr r r rH P s zCompat32.fold_binaryc C s g }|j d| t|tr\t|rL|r s L
( fPK ! y / __pycache__/_encoded_words.cpython-36.opt-1.pycnu [ 3
\F! @ s d Z ddlZddlZddlZddlZddlmZmZ ddlm Z ddddd d
d d gZ
ej ej d
j
dd Zdd ZG dd deZe Zdeed< dd Zdd Zdd Zdd Zdd
ZeedZdd ZeedZeedZ d d d Z dS ) z Routines for manipulating RFC2047 encoded words.
This is currently a package-private API, but will be considered for promotion
to a public API if there is demand.
N)
ascii_lettersdigits)errorsdecode_qencode_qdecode_bencode_blen_qlen_bdecodeencodes =([a-fA-F0-9]{2})c C s t t| jddgS )N )bytesintgroup)m r ,/usr/lib64/python3.6/email/_encoded_words.pyA s r c C s | j dd} t| g fS )N _ )replace_q_byte_subber)encodedr r r r C s c @ s, e Zd Zdejd ejd Zdd ZdS ) _QByteMaps -!*+/asciic C s. || j krt|| |< ndj|| |< | | S )Nz={:02X})safechrformat)selfkeyr r r __missing__M s
z_QByteMap.__missing__N)__name__
__module__ __qualname__r r r r r" r r r r r I s r _ c C s dj dd | D S )N c s s | ]}t | V qd S )N) _q_byte_map).0xr r r Z s zencode_q..)join)bstringr r r r Y s c C s t dd | D S )Nc s s | ]}t t| V qd S )N)lenr) )r* r+ r r r r, ] s zlen_q..)sum)r. r r r r \ s c C s t | d }|r dd d| nd}y$tj| | dd|rDtj gng fS tjk
r ytj| ddtj gfS tjk
r y"tj| d ddtj tj gfS tjk
r | tj gfS X Y nX Y nX d S )N s === T)ZvalidateFs ==) r/ base64Z b64decoder ZInvalidBase64PaddingDefectbinasciiErrorZ InvalidBase64CharactersDefectZInvalidBase64LengthDefect)r Zpad_errZmissing_paddingr r r r d s c C s t j| jdS )Nr )r3 Z b64encoder )r. r r r r s c C s& t t| d\}}|d |r dnd S )N r1 r )divmodr/ )r. Z groups_of_3Zleftoverr r r r
s )qbc C s | j d\}}}}}|jd\}}}|j }|jdd}t| |\}}y|j|}W nv tk
r |jtj dj
| |j|d}Y nB t k
r |jdd}|j dkr|jtj dj
| Y nX ||||fS )a Decode encoded word and return (string, charset, lang, defects) tuple.
An RFC 2047/2243 encoded word has the form:
=?charset*lang?cte?encoded_string?=
where '*lang' may be omitted but the other parts may not be.
This function expects exactly such a string (that is, it does not check the
syntax and may raise errors if the string is not well formed), and returns
the encoded_string decoded first from its Content Transfer Encoding and
then from the resulting bytes into unicode using the specified charset. If
the cte-decoded string does not successfully decode using the specified
character set, a defect is added to the defects list and the unknown octets
are replaced by the unicode 'unknown' character \uFDFF.
The specified charset and language are returned. The default for language,
which is rarely if ever encountered, is the empty string.
?*r surrogateescapez:Encoded word contains bytes not decodable using {} charsetz unknown-8bitz sB $
&+PK !
s0 0 + __pycache__/_parseaddr.cpython-36.opt-1.pycnu [ 3
IiD @ s d Z ddddgZddlZddlZdZdZd Zd
d d d
dddddddddddddddd d d d d gZd!d"d#d$d%d&d'gZddddd9d:d;dd?d@dAdBd.Z d/d Z
d0d1 Z d2d Z d3d Z
d4d ZG d5d6 d6ZG d7d8 d8eZdS )CzcEmail address parsing code.
Lifted directly from rfc822.py. This should eventually be rewritten.
mktime_tz parsedate parsedate_tzquote N z, ZjanZfebZmarZaprZmayZjunZjulZaugsepoctZnovZdecZjanuaryZfebruaryZmarchZaprilZjuneZjulyZaugustZ septemberZoctoberZnovemberZdecemberZmonZtueZwedZthuZfriZsatZsuni i, i iX i i )ZUTZUTCZGMTZZASTZADTZESTZEDTZCSTZCDTZMSTZMDTZPSTZPDTc C s, t | }|sdS |d dkr$d|d< t|S )zQConvert a date string to a time tuple.
Accounts for military timezones.
N r )
_parsedate_tztuple)datares r (/usr/lib64/python3.6/email/_parseaddr.pyr - s c C s | sdS | j } | d jds.| d j tkr6| d= n.| d jd}|dkrd| d |d d | d< t| dkr| d j d}t|dkr|| dd } t| dkr | d }|jd}|dkr|jd}|dkr|d| ||d g| dd< n
| jd t| d
k rdS | dd
} | \}}}}}|j }|tkrZ||j }}|tkrZdS tj |d }|d krz|d 8 }|d dkr|dd }|jd }|dkr|| }}|d dkr|dd }|d j
s|| }}|d dkr|dd }|j d }t|d
kr$|\} }
d} n~t|dkr>|\} }
} ndt|dkrd|d kr|d j d}t|d
kr|\} }
d} nt|dkr|\} }
} ndS y,t |}t |}t | } t |
}
t | } W n t k
r dS X |dk r |dkr|d7 }n|d7 }d} |j
}|tkr,t| } n>y t |} W n t k
rN Y nX | dkrj|jdrjd} | r| dk rd }
| } nd}
|
| d d | d d } |||| |
| ddd | g
S ) a Convert date to extended time tuple.
The last (additional) element is the time zone offset in seconds, except if
the timezone was specified as -0000. In that case the last element is
None. This indicates a UTC timestamp that explicitly declaims knowledge of
the source timezone, as opposed to a +0000 timestamp that indicates the
source timezone really was UTC.
Nr , - +r : 0.d D il i i < r! r! r! r! r! r! r! r! )splitendswithlower _daynamesrfindlenfindappend _monthnamesindexisdigitint
ValueErrorupper
_timezones
startswith)r iZstuffsZddZmmZyyZtmZtzZthhZtmmZtssZtzoffsetZtzsignr r r r 9 s
"
r c C s& t | }t|tr |dd S |S dS )z&Convert a time string to a time tuple.Nr )r
isinstancer
)r tr r r r s
c C s< | d dkr"t j| dd d S tj| }|| d S dS )zETurn a 10-tuple as returned by parsedate_tz() into a POSIX timestamp.r N r r! )r! )timeZmktimecalendarZtimegm)r r5 r r r r s
c C s | j ddj ddS )zPrepare string to be used in a quoted string.
Turns backslash and double quote characters into quoted pairs. These
are the only characters that need to be quoted inside a quoted string.
Does not add the surrounding double quotes.
\z\\"z\")replace)strr r r r s c @ s| e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
d ddZ dd Z dd Z
dd Zd ddZd d ZdS )
AddrlistClassa Address parser class by Ben Escoto.
To understand what this class does, it helps to have a copy of RFC 2822 in
front of you.
Note: this class interface is deprecated and may be removed in the future.
Use email.utils.AddressList instead.
c C sZ d| _ d| _d| _d| _| j| j | _| j | j | j | _| jjdd| _|| _g | _ dS )zInitialize a new instance.
`field' is an unparsed address header field, containing
one or more addresses.
z ()<>@,:;."[]r z z
r r N)
specialsposLWSZCRFWSatomendsr;
phraseendsfield commentlist)selfrD r r r __init__ s zAddrlistClass.__init__c C s g }x| j t| jk r| j| j | jd kr^| j| j dkrN|j| j| j | j d7 _ q| j| j dkr| jj| j qP qW tj|S )z&Skip white space and extract comments.z
r () r? r' rD r@ r) rE
getcomment EMPTYSTRINGjoin)rF Zwslistr r r gotonext s zAddrlistClass.gotonextc C s> g }x4| j t| jk r8| j }|r,||7 }q|jd qW |S )zVParse all addresses.
Returns a list containing all of the addresses.
r )r r )r? r' rD
getaddressr) )rF resultZadr r r getaddrlist s
zAddrlistClass.getaddrlistc C s g | _ | j | j}| j }| j }| j g }| jt| jkr\|rXtj| j |d fg}n\| j| j dkr|| _|| _ | j }tj| j |fg}n"| j| j dkr g }t| j}| jd7 _x| jt| jk r| j | j|k o| j| j dkr | jd7 _P || j }qW n| j| j dkrx| j
}| j rftj|d dj| j d |fg}ntj||fg}n@|rtj| j |d fg}n"| j| j | j kr| jd7 _| j | jt| jk r| j| j d
kr| jd7 _|S ) zParse the next address.r z.@r r ; )rF ZoldposZoldclplistZ
returnlistZaddrspecZfieldlenZ routeaddrr r r rM sL
&$zAddrlistClass.getaddressc C s | j | j dkrdS d}| jd7 _| j d}x| jt| j k r|rV| j d}n~| j | j dkrx| jd7 _P n\| j | j dkr| jd7 _d}n8| j | j d kr| jd7 _n| j }| jd7 _P | j q4W |S )
zParse a route address (Return-path value).
This method just skips all the route stuff and returns the addrspec.
rQ NFr r >@Tr )rD r? rL r' getdomainrU )rF Z expectrouteZadlistr r r rV ? s. zAddrlistClass.getrouteaddrc C s\ g }| j x| jt| jk rd}| j| j dkrj|rL|d j rL|j |jd | jd7 _d}nf| j| j dkr|jdt| j n>| j| j | j kr|r|d j r|j P n|j| j
| j }|r|r|j| qW | jt| jks| j| j dkr t j |S |jd | jd7 _| j | j
}|sNt S t j || S )
z Parse an RFC 2822 addr-spec.Tr r Fr: z"%s"rY r! r! )rL r? r' rD strippopr) r getquoterB getatomrJ rK rZ )rF ZaslistZ preserve_wsZwsZdomainr r r rU _ s:
$
zAddrlistClass.getaddrspecc C s g }x| j t| jk r| j| j | jkr8| j d7 _ q| j| j dkrZ| jj| j q| j| j dkrz|j| j q| j| j dkr| j d7 _ |jd q| j| j dkrtS | j| j | j krP q|j| j
qW tj |S )z-Get the complete domain name from an address.r rH [r rY ) r? r' rD r@ rE r) rI getdomainliteralrJ rB r^ rK )rF Zsdlistr r r rZ s" zAddrlistClass.getdomainTc C s | j | j |krdS dg}d}| jd7 _x| jt| j k r|rZ|j| j | j d}np| j | j |kr|| jd7 _P nN|r| j | j dkr|j| j q.n(| j | j dkrd}n|j| j | j | jd7 _q.W tj|S )a Parse a header fragment delimited by special characters.
`beginchar' is the start character for the fragment.
If self is not looking at an instance of `beginchar' then
getdelimited returns the empty string.
`endchars' is a sequence of allowable end-delimiting characters.
Parsing stops when one of these is encountered.
If `allowcomments' is non-zero, embedded RFC 2822 comments are allowed
within the parsed fragment.
r Fr rH r9 T)rD r? r' r) rI rJ rK )rF Z begincharZendcharsZ
allowcommentsZslistr r r r getdelimited s(
zAddrlistClass.getdelimitedc C s | j dddS )z1Get a quote-delimited fragment from self's field.r: z"
F)ra )rF r r r r] s zAddrlistClass.getquotec C s | j dddS )z7Get a parenthesis-delimited fragment from self's field.rH z)
T)ra )rF r r r rI s zAddrlistClass.getcommentc C s d| j ddd S )z!Parse an RFC 2822 domain-literal.z[%s]r_ z]
F)ra )rF r r r r` s z AddrlistClass.getdomainliteralNc C sh dg}|dkr| j }xH| jt| jk r\| j| j |kr:P n|j| j| j | jd7 _qW tj|S )a Parse an RFC 2822 atom.
Optional atomends specifies a different set of end token delimiters
(the default is to use self.atomends). This is used e.g. in
getphraselist() since phrase endings must not include the `.' (which
is legal in phrases).r Nr )rB r? r' rD r) rJ rK )rF rB Zatomlistr r r r^ s zAddrlistClass.getatomc C s g }x| j t| jk r| j| j | jkr8| j d7 _ q| j| j dkrX|j| j q| j| j dkrz| jj| j q| j| j | jkrP q|j| j | j qW |S )zParse a sequence of RFC 2822 phrases.
A phrase is a sequence of words, which are in turn either RFC 2822
atoms or quoted-strings. Phrases are canonicalized by squeezing all
runs of continuous whitespace into one space.
r r: rH )
r? r' rD rA r) r] rE rI rC r^ )rF rW r r r rS s zAddrlistClass.getphraselist)T)N)__name__
__module__ __qualname____doc__rG rL rO rM rV rU rZ ra r] rI r` r^ rS r r r r r= s ; &
%
r= c @ sH e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dS ) AddressListz@An AddressList encapsulates a list of parsed RFC 2822 addresses.c C s& t j| | |r | j | _ng | _d S )N)r= rG rO addresslist)rF rD r r r rG s zAddressList.__init__c C s
t | jS )N)r' rg )rF r r r __len__ s zAddressList.__len__c C sB t d }| jd d |_x$|jD ]}|| jkr |jj| q W |S )N)rf rg r) )rF othernewaddrxr r r __add__ s
zAddressList.__add__c C s* x$|j D ]}|| j kr| j j| qW | S )N)rg r) )rF ri rk r r r __iadd__
s
zAddressList.__iadd__c C s2 t d }x$| jD ]}||jkr|jj| qW |S )N)rf rg r) )rF ri rj rk r r r __sub__ s
zAddressList.__sub__c C s* x$|j D ]}|| j kr| j j| qW | S )N)rg remove)rF ri rk r r r __isub__ s
zAddressList.__isub__c C s
| j | S )N)rg )rF r+ r r r __getitem__# s zAddressList.__getitem__N) rb rc rd re rG rh rl rm rn rp rq r r r r rf s rf ipii ipii iDiiiD)re __all__r7 r8 rT rJ Z
COMMASPACEr* r% r0 r r r r r r= rf r r r r s8
u
/PK ! U
' __pycache__/parser.cpython-36.opt-2.pycnu [ 3
\ @ s| d dddddgZ ddlmZmZ ddlmZmZ dd lmZ G d
d d Z G d d de Z
G d d dZ G d
d de Z dS )Parser HeaderParser BytesParserBytesHeaderParser
FeedParserBytesFeedParser )StringIO
TextIOWrapper)r r )compat32c @ s0 e Zd Zd
edddZd ddZd dd ZdS )
r N)policyc C s || _ || _d S )N)_classr )selfr r r $/usr/lib64/python3.6/email/parser.py__init__ s zParser.__init__Fc C sD t | j| jd}|r |j x |jd}|s.P |j| q W |j S )N)r i )r r r Z_set_headersonlyreadZfeedclose)r
fp headersonlyZ
feedparserdatar r r parse* s
z Parser.parsec C s | j t||dS )N)r )r r )r
textr r r r parsestr< s zParser.parsestr)N)F)F)__name__
__module__ __qualname__r
r r r r r r r r s
c @ s e Zd ZdddZdddZdS ) r Tc C s t j| |dS )NT)r r )r
r r r r r r I s zHeaderParser.parsec C s t j| |dS )NT)r r )r
r r r r r r L s zHeaderParser.parsestrN)T)T)r r r r r r r r r r H s
c @ s( e Zd Zdd Zd ddZd
ddZdS ) r c O s t ||| _d S )N)r parser)r
argskwr r r r R s zBytesParser.__init__Fc
C s, t |ddd}z| jj||S |j X d S )Nasciisurrogateescape)encodingerrors)r r r detach)r
r r r r r r d s zBytesParser.parsec C s |j ddd}| jj||S )NASCIIr )r" )decoder r )r
r r r r r
parsebytess s zBytesParser.parsebytesN)F)F)r r r r r r& r r r r r P s
c @ s e Zd ZdddZdddZdS ) r Tc C s t j| |ddS )NT)r )r r )r
r r r r r r s zBytesHeaderParser.parsec C s t j| |ddS )NT)r )r r& )r
r r r r r r& s z BytesHeaderParser.parsebytesN)T)T)r r r r r& r r r r r s
N)
__all__ior r Zemail.feedparserr r Zemail._policybaser
r r r r r r r r s 7/PK ! 8% % ! __pycache__/policy.cpython-36.pycnu [ 3
\( @ s d Z ddlZddlmZmZmZmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ dd d
d d d
ddgZejdZeG dd d eZe Ze`ejddZejddZejdddZejddZdS )zcThis will be the home for the policy that hooks in the new
code that adds all the email6 features.
N)PolicyCompat32compat32_extend_docstrings)_has_surrogates)HeaderRegistry)raw_data_manager) EmailMessager r r EmailPolicydefaultstrictSMTPHTTPz\n|\rc sp e Zd ZdZeZdZdZe Z e
Z fddZ dd Z
dd Zd
d Zd d
Zdd Zdd ZdddZ ZS )r
aQ +
PROVISIONAL
The API extensions enabled by this policy are currently provisional.
Refer to the documentation for details.
This policy adds new header parsing and folding algorithms. Instead of
simple strings, headers are custom objects with custom attributes
depending on the type of the field. The folding algorithm fully
implements RFCs 2047 and 5322.
In addition to the settable attributes listed above that apply to
all Policies, this policy adds the following additional attributes:
utf8 -- if False (the default) message headers will be
serialized as ASCII, using encoded words to encode
any non-ASCII characters in the source strings. If
True, the message headers will be serialized using
utf8 and will not contain encoded words (see RFC
6532 for more on this serialization format).
refold_source -- if the value for a header in the Message object
came from the parsing of some source, this attribute
indicates whether or not a generator should refold
that value when transforming the message back into
stream form. The possible values are:
none -- all source values use original folding
long -- source values that have any line that is
longer than max_line_length will be
refolded
all -- all values are refolded.
The default is 'long'.
header_factory -- a callable that takes two arguments, 'name' and
'value', where 'name' is a header field name and
'value' is an unfolded header field value, and
returns a string-like object that represents that
header. A default header_factory is provided that
understands some of the RFC5322 header field types.
(Currently address fields and date fields have
special treatment, while all other fields are
treated as unstructured. This list will be
completed before the extension is marked stable.)
content_manager -- an object with at least two methods: get_content
and set_content. When the get_content or
set_content method of a Message 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. The default
content_manager is
:data:`~email.contentmanager.raw_data_manager`.
Flongc s* d|krt j| dt t jf | d S )Nheader_factory)object __setattr__r super__init__)selfkw) __class__ $/usr/lib64/python3.6/email/policy.pyr \ s zEmailPolicy.__init__c C s | j | jS )z+
The implementation for this class returns the max_count attribute from
the specialized header class that would be used to construct a header
of type 'name'.
)r Z max_count)r namer r r header_max_countc s z EmailPolicy.header_max_countc C s> |d j dd\}}|jddj|dd }||jdfS )ac +
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. (This
is the same as Compat32).
r : z Nz
)splitlstripjoinrstrip)r Z sourcelinesr valuer r r header_source_parseu s z EmailPolicy.header_source_parsec C sV t |dr$|jj |j kr$||fS t|trFt|j dkrFtd|| j||fS )a +
The name is returned unchanged. If the input value has a 'name'
attribute and it matches the name ignoring case, the value is returned
unchanged. Otherwise the name and value are passed to header_factory
method, and the resulting custom header object is returned as the
value. In this case a ValueError is raised if the input value contains
CR or LF characters.
r r zDHeader values may not contain linefeed or carriage return characters) hasattrr lower
isinstancestrlen
splitlines
ValueErrorr )r r r# r r r header_store_parse s
z EmailPolicy.header_store_parsec C s* t |dr|S djtj|}| j||S )ai +
If the value has a 'name' attribute, it is returned to unmodified.
Otherwise the name and the value with any linesep characters removed
are passed to the header_factory method, and the resulting custom
header object is returned. Any surrogateescaped bytes get turned
into the unicode unknown-character glyph.
r r )r% r! linesep_splitterr r )r r r# r r r header_fetch_parse s
z EmailPolicy.header_fetch_parsec C s | j ||ddS )a +
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 custom header object by passing
the name and the value with any linesep characters removed to the
header_factory method. Folding of a custom 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 charset.
T)
refold_binary)_fold)r r r# r r r fold s zEmailPolicy.foldc C s0 | j ||| jdkd}| jr dnd}|j|dS )a +
The same as fold if cte_type is 7bit, except that the returned value is
bytes.
If 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.
If utf8 is true, headers are encoded to utf8, otherwise to ascii with
non-ASCII unicode rendered as encoded words.
Z7bit)r/ utf8asciisurrogateescape)r0 Zcte_typer2 encode)r r r# Zfoldedcharsetr r r fold_binary s zEmailPolicy.fold_binaryc s t |dr|j| dS | jr"| jntd |j }| jdkp| jdko|rft|d t| d kpt fdd |d
d D }|s|rt|r| j |d j
|j| dS |d | j j
| | j S )
Nr )Zpolicyinfallr r c 3 s | ]}t | kV qd S )N)r) ).0x)maxlenr r s z$EmailPolicy._fold..r r z: ) r% r1 max_line_lengthfloatr*
refold_sourcer) anyr r r! linesep)r r r# r/ linesZrefoldr )r= r r0 s
zEmailPolicy._fold)F)__name__
__module__ __qualname____doc__r Zmessage_factoryr2 rA r r r Zcontent_managerr r r$ r, r. r1 r7 r0
__classcell__r r )r r r
s ;
T)Zraise_on_defectz
)rC )rC r? )r2 )rH reZemail._policybaser r r r Z email.utilsr Zemail.headerregistryr Zemail.contentmanagerr Z
email.messager __all__compiler- r
r r Zcloner r
r ZSMTPUTF8r r r r s0
@ PK ! _j j ( __pycache__/message.cpython-36.opt-1.pycnu [ 3
\ @ s d Z ddgZddlZddlZddlZddlmZmZ ddlm Z ddlm
Z
ddl m Z m
Z
dd lmZ dd
lmZ ejZd Zejd Zd
d ZdddZdd Zdd ZG dd dZG dd deZG dd deZ dS )z8Basic message object for the email package object model.Message EmailMessage N)BytesIOStringIO)utils)errors)Policycompat32)charset)decode_bz; z[ \(\)<>@,;:\\"/\[\]\?=]c C s4 t | jd\}}}|s$|j d fS |j |j fS )N;)str partitionstrip)paramasepb r %/usr/lib64/python3.6/email/message.py _splitparam s r Tc C s |dk rt |dkrt|trL| d7 } tj|d |d |d }d| |f S y|jd W n2 tk
r | d7 } tj|dd }d| |f S X |stj|rd
| tj |f S d| |f S n| S dS ) a~ Convenience function to format and return a key=value pair.
This will quote the value if needed or if quote is true. If value is a
three tuple (charset, language, value), it will be encoded according
to RFC2231 rules. If it contains non-ascii characters it will likewise
be encoded according to RFC2231 rules, using the utf-8 charset and
a null language.
Nr * z%s=%sasciizutf-8 z%s="%s")
len
isinstancetupler Zencode_rfc2231encodeUnicodeEncodeError tspecialssearchquote)r valuer# r r r _formatparam' s
r% c C s dt | } g }x| d d dkr| dd } | jd}x<|dkrt| jdd|| jdd| d rt| jd|d }q:W |dk rt| }| d | }d|kr|jd}|d | j j d ||d d j }|j|j | |d } qW |S )Nr r r "z\"r =)r
findcountr indexr lowerappend)sZplistendfir r r _parseparamI s
*
,r1 c C s4 t | tr&| d | d tj| d fS tj| S d S )Nr r r )r r r unquote)r$ r r r
_unquotevalue] s
r3 c @ s e Zd ZdZefddZdd Zddd d
Zd d Zded
dZ dd Z
dd Z dd Z dd Z
dfddZdgddZdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zdhd1d2Zd3d4 Z d5d6 Z did7d8Z d9d: Z d;d< Z d=d> Z!d?d@ Z"dAdB Z#dCdD Z$dEdF Z%dGdH Z&djdKdLZ'dkdMdNZ(dldQdRZ)dmdSdTZ*dndUdVZ+dodWdXZ,dpdYdZZ-d[d\ Z.dqd]d^Z/drd_d`Z0dadb Z1ddcl2m3Z3 dS )sr a Basic message object.
A message object is defined as something that has a bunch of RFC 2822
headers and a payload. It may optionally have an envelope header
(a.k.a. Unix-From or From_ header). If the message is a container (i.e. a
multipart or a message/rfc822), then the payload is a list of Message
objects, otherwise it is a string.
Message objects implement part of the `mapping' interface, which assumes
there is exactly one occurrence of the header per message. Some headers
do in fact appear multiple times (e.g. Received) and for those headers,
you must use the explicit API to set or get all the headers. Not all of
the mapping methods are implemented.
c C s: || _ g | _d | _d | _d | _d | _| _g | _d| _d S )Nz
text/plain) policy_headers _unixfrom_payload_charsetZpreambleZepiloguedefects
_default_type)selfr4 r r r __init__x s zMessage.__init__c C s | j S )z9Return the entire formatted message as a string.
) as_string)r; r r r __str__ s zMessage.__str__Fr Nc C sJ ddl m} |dkr| jn|}t }||d||d}|j| |d |j S )a Return the entire formatted message as a string.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. For backward compatibility reasons, if maxheaderlen is
not specified it defaults to 0, so you must override it explicitly
if you want a different maxheaderlen. 'policy' is passed to the
Generator instance used to serialize the mesasge; if it is not
specified the policy associated with the message instance is used.
If the message object contains binary data that is not encoded
according to RFC standards, the non-compliant data will be replaced by
unicode "unknown character" code points.
r ) GeneratorNF) mangle_from_ maxheaderlenr4 )unixfrom)email.generatorr? r4 r flattengetvalue)r; rB rA r4 r? fpgr r r r= s zMessage.as_stringc C s | j S )z?Return the entire formatted message as a bytes object.
)as_bytes)r; r r r __bytes__ s zMessage.__bytes__c C sH ddl m} |dkr| jn|}t }||d|d}|j| |d |j S )aJ Return the entire formatted message as a bytes object.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. 'policy' is passed to the BytesGenerator instance used to
serialize the message; if not specified the policy associated with
the message instance is used.
r )BytesGeneratorNF)r@ r4 )rB )rC rJ r4 r rD rE )r; rB r4 rJ rF rG r r r rH s zMessage.as_bytesc C s t | jtS )z6Return True if the message consists of multiple parts.)r r7 list)r; r r r is_multipart s zMessage.is_multipartc C s
|| _ d S )N)r6 )r; rB r r r set_unixfrom s zMessage.set_unixfromc C s | j S )N)r6 )r; r r r get_unixfrom s zMessage.get_unixfromc C sF | j dkr|g| _ n.y| j j| W n tk
r@ tdY nX dS )zAdd the given payload to the current payload.
The current payload will always be a list of objects after this method
is called. If you want to set the payload to a scalar object, use
set_payload() instead.
Nz=Attach is not valid on a message with a non-multipart payload)r7 r, AttributeError TypeError)r; payloadr r r attach s
zMessage.attachc C s | j r(|rdS |dkr | jS | j| S |dk rPt| jt rPtdt| j | j}t| jddj }t|trt j
|r|j dd}|sy|j | j
ddd}W n tk
r |j dd}Y nX n6|ry|j d}W n tk
r |j d }Y nX |s |S |d
kr tj|S |d krbtd j|j \}}x |D ]}| jj| | qFW |S |dkrt|} t }
ytj | |
dd |
j S tjk
r |S X t|tr|S |S )aZ Return a reference to the payload.
The payload will either be a list object or a string. If you mutate
the list object, you modify the message's payload in place. Optional
i returns that index into the payload.
Optional decode is a flag indicating whether the payload should be
decoded or not, according to the Content-Transfer-Encoding header
(default is False).
When True and the message is not a multipart, the payload will be
decoded if this header's value is `quoted-printable' or `base64'. If
some other encoding is used, or the header is missing, or if the
payload has bogus data (i.e. bogus base64 or uuencoded data), the
payload is returned as-is.
If the message is a multipart and the decode flag is True, then None
is returned.
NzExpected list, got %szcontent-transfer-encodingr r surrogateescaper
replacezraw-unicode-escapezquoted-printablebase64
x-uuencodeuuencodeuuex-uueT)quiet)rW rX rY rZ )rL r7 r rK rP typer
getr+ r Z_has_surrogatesr decode get_param LookupError UnicodeErrorquopriZ decodestringr join
splitlinesr4 Z
handle_defectr uurE Error) r; r0 r^ rQ cteZbpayloadr$ r9 ZdefectZin_fileZout_filer r r get_payload sV "
zMessage.get_payloadc C sp t |dr:|dkr || _dS t|ts.t|}|j|j}t |drT|jdd| _n|| _|dk rl| j| dS )zSet the payload to the given value.
Optional charset sets the message's default character set. See
set_charset() for details.
r Nr^ r rS )hasattrr7 r Charsetr output_charsetr^ set_charset)r; rQ r
r r r set_payload/ s
zMessage.set_payloadc C s |dkr | j d d| _dS t|ts.t|}|| _d| krH| jdd d| krf| jdd|j d n| jd|j ||j kr|j| j| _d| kr|j }y || W nj t
k
r | j}|ry|j d d
}W n t k
r |j |j
}Y nX |j|| _| jd| Y nX dS ) a Set the charset of the payload to a given character set.
charset can be a Charset instance, a string naming a character set, or
None. If it is a string it will be converted to a Charset instance.
If charset is None, the charset parameter will be removed from the
Content-Type field. Anything else will generate a TypeError.
The message will be assumed to be of type text/* encoded with
charset.input_charset. It will be converted to charset.output_charset
and encoded properly, if needed, when generating the plain text
representation of the message. MIME headers (MIME-Version,
Content-Type, Content-Transfer-Encoding) will be added as needed.
Nr
z MIME-Versionz1.0z Content-Typez
text/plain)r
zContent-Transfer-Encodingr rS ) del_paramr8 r rj
add_headerZget_output_charset set_paramZ body_encoder7 Zget_body_encodingrP r ra rk )r; r
rg rQ r r r rl C s8
zMessage.set_charsetc C s | j S )zKReturn the Charset instance associated with the message's payload.
)r8 )r; r r r get_charsetr s zMessage.get_charsetc C s
t | jS )z9Return the total number of headers, including duplicates.)r r5 )r; r r r __len__z s zMessage.__len__c C s
| j |S )a- Get a header value.
Return None if the header is missing instead of raising an exception.
Note that if the header appeared multiple times, exactly which
occurrence gets returned is undefined. Use get_all() to get all
the values matching a header field name.
)r] )r; namer r r __getitem__~ s zMessage.__getitem__c C sv | j j|}|r\|j }d}x>| jD ]4\}}|j |kr$|d7 }||kr$tdj||q$W | jj| j j|| dS )zSet the value of a header.
Note: this does not overwrite an existing header with the same field
name. Use __delitem__() first to delete any existing headers.
r r z/There may be at most {} {} headers in a messageN)r4 Zheader_max_countr+ r5
ValueErrorformatr, header_store_parse)r; rs valZ max_countZlnamefoundkvr r r __setitem__ s zMessage.__setitem__c C sD |j }g }x,| jD ]"\}}|j |kr|j||f qW || _dS )zwDelete all occurrences of a header, if present.
Does not raise an exception if the header is missing.
N)r+ r5 r, )r; rs
newheadersrz r{ r r r __delitem__ s zMessage.__delitem__c C s |j dd | jD kS )Nc S s g | ]\}}|j qS r )r+ ).0rz r{ r r r
s z(Message.__contains__..)r+ r5 )r; rs r r r __contains__ s zMessage.__contains__c c s x| j D ]\}}|V qW d S )N)r5 )r; Zfieldr$ r r r __iter__ s zMessage.__iter__c C s dd | j D S )a. Return a list of all the message's header field names.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c S s g | ] \}}|qS r r )r rz r{ r r r r s z Message.keys..)r5 )r; r r r keys s z Message.keysc s fdd j D S )a) Return a list of all the message's header values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c s g | ]\}} j j||qS r )r4 header_fetch_parse)r rz r{ )r; r r r s z"Message.values..)r5 )r; r )r; r values s
zMessage.valuesc s fdd j D S )a' Get all the message's header fields and values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c s" g | ]\}}| j j||fqS r )r4 r )r rz r{ )r; r r r s z!Message.items..)r5 )r; r )r; r items s
z
Message.itemsc C s: |j }x,| jD ]"\}}|j |kr| jj||S qW |S )z~Get a header value.
Like __getitem__() but return failobj instead of None when the field
is missing.
)r+ r5 r4 r )r; rs failobjrz r{ r r r r] s
z Message.getc C s | j j||f dS )zStore name and value in the model without modification.
This is an "internal" API, intended only for use by a parser.
N)r5 r, )r; rs r$ r r r set_raw s zMessage.set_rawc C s t | jj S )zReturn the (name, value) header pairs without modification.
This is an "internal" API, intended only for use by a generator.
)iterr5 copy)r; r r r raw_items s zMessage.raw_itemsc C sL g }|j }x2| jD ](\}}|j |kr|j| jj|| qW |sH|S |S )aQ Return a list of all the values for the named field.
These will be sorted in the order they appeared in the original
message, and may contain duplicates. Any fields deleted and
re-inserted are always appended to the header list.
If no such fields exist, failobj is returned (defaults to None).
)r+ r5 r, r4 r )r; rs r r rz r{ r r r get_all s zMessage.get_allc K st g }xH|j D ]<\}}|dkr2|j|jdd q|jt|jdd| qW |dk rb|jd| tj|| |< dS )u Extended header setting.
name is the header field to add. keyword arguments can be used to set
additional parameters for the header field, with underscores converted
to dashes. Normally the parameter will be added as key="value" unless
value is None, in which case only the key will be added. If a
parameter value contains non-ASCII characters it can be specified as a
three-tuple of (charset, language, value), in which case it will be
encoded according to RFC2231 rules. Otherwise it will be encoded using
the utf-8 charset and a language of ''.
Examples:
msg.add_header('content-disposition', 'attachment', filename='bud.gif')
msg.add_header('content-disposition', 'attachment',
filename=('utf-8', '', Fußballer.ppt'))
msg.add_header('content-disposition', 'attachment',
filename='Fußballer.ppt'))
N_-r )r r, rT r% insert SEMISPACErc )r; _name_valueZ_paramspartsrz r{ r r r ro s zMessage.add_headerc C s^ |j }xPttt| j| jD ].\}\}}|j |kr | jj||| j|< P q W t|dS )zReplace a header.
Replace the first matching header found in the message, retaining
header order and case. If no matching header was found, a KeyError is
raised.
N)r+ zipranger r5 r4 rw KeyError)r; r r r0 rz r{ r r r replace_header! s $ zMessage.replace_headerc C sH t }| jd|}||kr"| j S t|d j }|jddkrDdS |S )a0 Return the message's content type.
The returned string is coerced to lower case of the form
`maintype/subtype'. If there was no Content-Type header in the
message, the default type as given by get_default_type() will be
returned. Since according to RFC 2045, messages always have a default
type this will always return a value.
RFC 2045 defines a message's default type to be text/plain unless it
appears inside a multipart/digest container, in which case it would be
message/rfc822.
z content-typer /r z
text/plain)objectr] get_default_typer r+ r) )r; missingr$ ctyper r r get_content_type4 s
zMessage.get_content_typec C s | j }|jdd S )zReturn the message's main content type.
This is the `maintype' part of the string returned by
get_content_type().
r r )r split)r; r r r r get_content_maintypeL s z Message.get_content_maintypec C s | j }|jdd S )zReturns the message's sub-content type.
This is the `subtype' part of the string returned by
get_content_type().
r r )r r )r; r r r r get_content_subtypeU s zMessage.get_content_subtypec C s | j S )a Return the `default' content type.
Most messages have a default content type of text/plain, except for
messages that are subparts of multipart/digest containers. Such
subparts have a default content type of message/rfc822.
)r: )r; r r r r ^ s zMessage.get_default_typec C s
|| _ dS )zSet the `default' content type.
ctype should be either "text/plain" or "message/rfc822", although this
is not enforced. The default content type is not stored in the
Content-Type header.
N)r: )r; r r r r set_default_typeg s zMessage.set_default_typec C s t }| j||}||kr |S g }xdt|D ]X}y$|jdd\}}|j }|j }W n tk
rt |j }d}Y nX |j||f q,W tj|}|S )Nr' r r ) r r] r1 r r ru r, r Z
decode_params) r; r headerr r$ paramsprs rx r r r _get_params_preservep s
z Message._get_params_preserve content-typeTc C s8 t }| j||}||kr |S |r0dd |D S |S dS )am Return the message's Content-Type parameters, as a list.
The elements of the returned list are 2-tuples of key/value pairs, as
split on the `=' sign. The left hand side of the `=' is the key,
while the right hand side is the value. If there is no `=' sign in
the parameter the value is the empty string. The value is as
described in the get_param() method.
Optional failobj is the object to return if there is no Content-Type
header. Optional header is the header to search instead of
Content-Type. If unquote is True, the value is unquoted.
c S s g | ]\}}|t |fqS r )r3 )r rz r{ r r r r s z&Message.get_params..N)r r )r; r r r2 r r r r r
get_params s
zMessage.get_paramsc C sJ || kr |S x8| j ||D ](\}}|j |j kr|r>t|S |S qW |S )a Return the parameter value if found in the Content-Type header.
Optional failobj is the object to return if there is no Content-Type
header, or the Content-Type header has no such parameter. Optional
header is the header to search instead of Content-Type.
Parameter keys are always compared case insensitively. The return
value can either be a string, or a 3-tuple if the parameter was RFC
2231 encoded. When it's a 3-tuple, the elements of the value are of
the form (CHARSET, LANGUAGE, VALUE). Note that both CHARSET and
LANGUAGE can be None, in which case you should consider VALUE to be
encoded in the us-ascii charset. You can usually ignore LANGUAGE.
The parameter value (either the returned string, or the VALUE item in
the 3-tuple) is always unquoted, unless unquote is set to False.
If your application doesn't care whether the parameter was RFC 2231
encoded, it can turn the return value into a string as follows:
rawparam = msg.get_param('foo')
param = email.utils.collapse_rfc2231_value(rawparam)
)r r+ r3 )r; r r r r2 rz r{ r r r r_ s zMessage.get_param Content-Typer c C s t |t r|r|||f}|| kr4|j dkr4d}n
| j|}| j||dsv|s^t|||}qtj|t|||g}nfd}x`| j||dD ]N\} }
d} | j |j krt|||} n t| |
|} |s| }qtj|| g}qW || j|kr|r | j || n| |= || |< dS )a Set a parameter in the Content-Type header.
If the parameter already exists in the header, its value will be
replaced with the new value.
If header is Content-Type and has not yet been defined for this
message, it will be set to "text/plain" and the new parameter and
value will be appended as per RFC 2045.
An alternate header can be specified in the header argument, and all
parameters will be quoted as necessary unless requote is False.
If charset is specified, the parameter will be encoded according to RFC
2231. Optional language specifies the RFC 2231 language, defaulting
to the empty string. Both charset and language should be strings.
z content-typez
text/plain)r r )r r2 N)
r r r+ r] r_ r% r rc r r ) r; r r$ r requoter
ZlanguagerT r Z old_paramZ old_valueZ append_paramr r r rp s2
zMessage.set_paramc C s || kr dS d}xR| j ||dD ]@\}}|j |j kr |sJt|||}q tj|t|||g}q W || j|kr| |= || |< dS )a> Remove the given parameter completely from the Content-Type header.
The header will be re-written in place without the parameter or its
value. All values will be quoted as necessary unless requote is
False. Optional header specifies an alternative to the Content-Type
header.
Nr )r r2 )r r+ r% r rc r] )r; r r r Z new_ctyper r{ r r r rn s zMessage.del_paramc C s |j ddkst|j dkr,| d= d| d< || kr@|| |< dS | j||d}| |= || |< x(|dd D ]\}}| j|||| qjW dS ) aK Set the main type and subtype for the Content-Type header.
type must be a string in the form "maintype/subtype", otherwise a
ValueError is raised.
This method replaces the Content-Type header, keeping all the
parameters in place. If requote is False, this leaves the existing
header's quoting as is. Otherwise, the parameters will be quoted (the
default).
An alternative header can be specified in the header argument. When
the Content-Type header is set, we'll always also add a MIME-Version
header.
r r z content-typez mime-versionz1.0z MIME-VersionN)r r2 )r) ru r+ r rp )r; r\ r r r r r{ r r r set_type s zMessage.set_typec C sD t }| jd|d}||kr*| jd|d}||kr6|S tj|j S )a@ Return the filename associated with the payload if present.
The filename is extracted from the Content-Disposition header's
`filename' parameter, and it is unquoted. If that header is missing
the `filename' parameter, this method falls back to looking for the
`name' parameter.
filenamezcontent-dispositionrs z content-type)r r_ r collapse_rfc2231_valuer )r; r r r r r r get_filename& s zMessage.get_filenamec C s, t }| jd|}||kr |S tj|j S )zReturn the boundary associated with the payload if present.
The boundary is extracted from the Content-Type header's `boundary'
parameter, and it is unquoted.
boundary)r r_ r r rstrip)r; r r r r r r get_boundary6 s
zMessage.get_boundaryc C s t }| j|d}||kr$tjdg }d}xB|D ]:\}}|j dkr^|jdd| f d}q2|j||f q2W |s|jdd| f g }x| jD ]\} }
| j dkrg } x6|D ].\} }
|
dkr| j| q| jd| |
f qW tj| }
|j| j j
| |
q|j| |
f qW || _d S )
a Set the boundary parameter in Content-Type to 'boundary'.
This is subtly different than deleting the Content-Type header and
adding a new one with a new boundary parameter via add_header(). The
main difference is that using the set_boundary() method preserves the
order of the Content-Type header in the original message.
HeaderParseError is raised if the message has no Content-Type header.
z content-typez No Content-Type header foundFr z"%s"Tr z%s=%sN) r r r ZHeaderParseErrorr+ r, r5 r rc r4 rw )r; r r r Z newparamsZfoundpZpkZpvr} hr{ r rz rx r r r set_boundaryC s2
zMessage.set_boundaryc C s t }| jd|}||kr |S t|trr|d p2d}y |d jd}t||}W n ttfk
rp |d }Y nX y|jd W n tk
r |S X |j S )zReturn the charset parameter of the Content-Type header.
The returned string is always coerced to lower case. If there is no
Content-Type header, or if that header has no charset parameter,
failobj is returned.
r
r zus-asciir zraw-unicode-escape) r r_ r r r r
r` ra r+ )r; r r r
ZpcharsetrH r r r get_content_charsetq s
zMessage.get_content_charsetc s fdd| j D S )a Return a list containing the charset(s) used in this message.
The returned list of items describes the Content-Type headers'
charset parameter for this message and all the subparts in its
payload.
Each item will either be a string (the value of the charset parameter
in the Content-Type header of that part) or the value of the
'failobj' parameter (defaults to None), if the part does not have a
main MIME type of "text", or the charset is not defined.
The list will contain one string for each part of the message, plus
one for the container message (i.e. self), so that a non-multipart
message will still return a list of length 1.
c s g | ]}|j qS r )r )r part)r r r r s z(Message.get_charsets..)walk)r; r r )r r get_charsets s zMessage.get_charsetsc C s* | j d}|dkrdS t|d j }|S )zReturn the message's content-disposition if it exists, or None.
The return values can be either 'inline', 'attachment' or None
according to the rfc2183.
zcontent-dispositionNr )r] r r+ )r; r$ c_dr r r get_content_disposition s
z Message.get_content_disposition)r )Fr N)FN)NF)N)N)N)Nr T)Nr T)r TNr F)r T)r T)N)N)N)N)4__name__
__module__ __qualname____doc__r r< r> r= rI rH rL rM rN rR rh rm rl rq rr rt r| r~ r r r r r r] r r r ro r r r r r r r r r_ rp rn r r r r r r r Zemail.iteratorsr r r r r r i sb
Z
/
!
2
.
c s e Zd Zd3ddZd4 fdd Zdd Zd d
Zd d Zd6ddZd7d8d9d:hZ dd Z
dd Z ddddZ ddd d Z
d d Zd;d d!ZdMIMEPartNc C s( |d krddl m} |}tj| | d S )Nr )default)Z email.policyr r r< )r; r4 r r r r r< s zMIMEPart.__init__Fc s0 |dkr| j n|}|dkr |j}t j||dS )a Return the entire formatted message as a string.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. maxheaderlen is retained for backward compatibility with the
base Message class, but defaults to None, meaning that the policy value
for max_line_length controls the header maximum length. 'policy' is
passed to the Generator instance used to serialize the mesasge; if it
is not specified the policy associated with the message instance is
used.
N)rA r4 )r4 Zmax_line_lengthsuperr= )r; rB rA r4 ) __class__r r r= s zMIMEPart.as_stringc C s | j | jjdddS )NT)utf8)r4 )r= r4 Zclone)r; r r r r> s zMIMEPart.__str__c C s | j d}|d krdS |jdkS )Nzcontent-dispositionF
attachment)r] Zcontent_disposition)r; r r r r
is_attachment s
zMIMEPart.is_attachmentc c s |j r d S |j jd\}}|dkrB||kr>|j||fV d S |dkrNd S |dkr~x"|j D ]}| j||E d H q`W d S d|kr|jd|fV d }|jd}|rx"|j D ]}|d |kr|}P qW |d kr|j }|r|d nd }|d k r| j||E d H d S )Nr text multipartrelatedstartz
content-idr )r r r r*
iter_parts
_find_bodyr_ rh ) r; r preferencelistmaintypesubtypeZsubpart candidater Zsubpartsr r r r s6
zMIMEPart._find_bodyr htmlplainc C sD t |}d}x2| j| |D ]"\}}||k r|}|}|dkrP qW |S )a Return best candidate mime part for display as 'body' of message.
Do a depth first search, starting with self, looking for the first part
matching each of the items in preferencelist, and return the part
corresponding to the first item that has a match, or None if no items
have a match. If 'related' is not included in preferencelist, consider
the root part of any multipart/related encountered as a candidate
match. Ignore parts with 'Content-Disposition: attachment'.
Nr )r r )r; r Z best_prioZbodyZprior r r r get_body s
zMIMEPart.get_bodyr r alternativec c s | j jd\}}|dks"|dkr&dS | j j }|dkr|dkr| jd}|rd}g }x*|D ]"}|jd|krvd }q^|j| q^W |r|E dH dS |jd
|E dH dS g }xP|D ]H}|j jd\}}||f| jkr|j r||kr|j| q|V qW dS ) a Return an iterator over the non-main parts of a multipart.
Skip the first of each occurrence of text/plain, text/html,
multipart/related, or multipart/alternative in the multipart (unless
they have a 'Content-Disposition: attachment' header) and include all
remaining subparts in the returned iterator. When applied to a
multipart/related, return all parts except the root part. Return an
empty iterator when applied to a multipart/alternative or a
non-multipart.
r r r Nr r Fz
content-idTr )
r r rh r r_ r] r, pop _body_typesr ) r; r r r r ry Z attachmentsr seenr r r iter_attachments s6
zMIMEPart.iter_attachmentsc c s | j dkr| j E dH dS )z~Return an iterator over all immediate subparts of a multipart.
Return an empty iterator for a non-multipart.
r N)r rh )r; r r r r 4 s zMIMEPart.iter_parts)content_managerc O s" |d kr| j j}|j| f||S )N)r4 r get_content)r; r argskwr r r r < s zMIMEPart.get_contentc O s& |d kr| j j}|j| f|| d S )N)r4 r set_content)r; r r r r r r r A s zMIMEPart.set_contentc
C s | j dkr6| j }||f }||kr6tdj||g }g }x>| jD ]4\}}|j jdrl|j||f qF|j||f qFW |rt| | j d} || _| j
| _
| g| _
ng | _
|| _d| | d< |d k r| j d| d S )Nr zCannot convert {} to {}zcontent-)r4 z
multipart/z Content-Typer ) r r ru rv r5 r+
startswithr, r\ r4 r7 rp )
r; r Zdisallowed_subtypesr Zexisting_subtypeZ keep_headersZ part_headersrs r$ r r r r _make_multipartF s,
zMIMEPart._make_multipartc C s | j dd| d S )Nr r mixed)r r )r )r; r r r r make_relateda s zMIMEPart.make_relatedc C s | j dd| d S )Nr r )r )r )r; r r r r make_alternatived s zMIMEPart.make_alternativec C s | j df | d S )Nr )r )r; r r r r
make_mixedg s zMIMEPart.make_mixed)_dispc O sf | j dks| j |kr(t| d| t| | jd}|j|| |rXd|krX||d< | j| d S )Nr Zmake_)r4 zcontent-dispositionzContent-Disposition)r r getattrr\ r4 r rR )r; Z_subtyper r r r r r r _add_multipartj s zMIMEPart._add_multipartc O s | j d|ddi| d S )Nr r Zinline)r )r )r; r r r r r add_relatedt s zMIMEPart.add_relatedc O s | j d|| d S )Nr )r )r )r; r r r r r add_alternativew s zMIMEPart.add_alternativec O s | j d|ddi| d S )Nr r r )r )r )r; r r r r r add_attachmentz s zMIMEPart.add_attachmentc C s g | _ d | _d S )N)r5 r7 )r; r r r clear} s zMIMEPart.clearc C s dd | j D | _ d | _d S )Nc S s& g | ] \}}|j jd s||fqS )zcontent-)r+ r )r nr{ r r r r s z*MIMEPart.clear_content..)r5 r7 )r; r r r
clear_content s zMIMEPart.clear_content)N)FNNr r r )r )r r )r r )r r )r r )N)N)N)r r r r< r= r> r r r r r r r r r r r r r r r r r r
__classcell__r r )r r r s0
.
r c s e Zd Z fddZ ZS )r c s" t j|| d| kr d| d< d S )Nz MIME-Versionz1.0)r r )r; r r )r r r r s zEmailMessage.set_content)r r r r r r r )r r r s )NT) r __all__rere rb ior r Zemailr r Zemail._policybaser r r
r8 Zemail._encoded_wordsr rj r compiler! r r% r1 r3 r r r r r r r s6
" N WPK ! ~j* j* ' __pycache__/header.cpython-36.opt-2.pycnu [ 3
\&^ @ s d ddgZ ddlZddlZddlZddlZddlmZ ddlmZ e j
Z
dZ dZ d Z
dZd Zd Zd
Ze
dZe
dZejdejejB ejB ZejdZejdZejj Z dd Z dddZ G dd d Z G dd dZ G dd de!Z"dS ) Header
decode_header make_header N)HeaderParseError)charset
N z zus-asciizutf-8ai
=\? # literal =?
(?P[^?]*?) # non-greedy up to the next ? is the charset
\? # literal ?
(?P[qb]) # either a "q" or a "b", case insensitive
\? # literal ?
(?P.*?) # non-greedy up to the next ?= is the encoded string
\?= # literal ?=
z[\041-\176]+:$z
\n[^ \t]+:c C s t | drdd | jD S tj| s.| d fgS g }x| j D ]}tj|}d}xp|r|jd}|rn|j }d}|r|j|d d f |rP|jdj }|jdj }|jd}|j|||f qPW qM s z!decode_header..Tr F qb z===zBase64 decoding errorzUnexpected encoding: zraw-unicode-escape)hasattrr
ecresearch
splitlinessplitpoplstripappendlower enumerateisspacereversedemail
quoprimimeZ
header_decodelenZ
base64mimedecodebinasciiErrorr AssertionError
isinstancer bytesBSPACE)headerZwordslinepartsfirstZ unencodedr encodingZencodedZdroplistnwdZ
decoded_wordsZencoded_stringZwordZpaderrZ collapsedZ last_word last_charsetr r r r = sz
4
c C sL t |||d}x8| D ]0\}}|d k r8t|t r8t|}|j|| qW |S )N)
maxlinelen header_namecontinuation_ws)r r- Charsetr! )Z decoded_seqr9 r: r; hsr r r r r s c @ sJ e Zd ZdddZdd Zdd Zdd
d Zd d
ZdddZdd Z dS )r Nr strictc C s| |d krt }nt|ts t|}|| _|| _g | _|d k rH| j||| |d krTt}|| _|d krjd| _ nt
|d | _ d S )Nr r ) USASCIIr- r< r _continuation_wsr
r!
MAXLINELEN _maxlinelen
_headerlenr( )selfr> r r9 r: r; errorsr r r __init__ s
zHeader.__init__c C s | j g }d }d }x| jD ]\}}|}|tjkrJ|jdd}|jdd}|r|o^| j|d }|dkr|dkr| r|jt d }n|d kr| r|jt |o| j|d
}|}|j| q W t j
|S ) Nasciisurrogateescapereplacer us-asciir )NrK )NrK )NrK )
_normalizer
r UNKNOWN8BITencoder) _nonctextr! SPACE EMPTYSTRINGjoin) rE Zuchunkslastcs lastspacer r ZnextcsZoriginal_byteshasspacer r r __str__ s*
zHeader.__str__c C s |t | kS )N)r )rE otherr r r __eq__ s z
Header.__eq__c C s |d kr| j }nt|ts"t|}t|tsZ|jp4d}|t jkrN|jdd}n |j||}|jpbd}|t jkry|j|| W n" t k
r |dkr t
}Y nX | j j ||f d S )Nzus-asciirI )
r r- r< r Z input_codecrN r) Z output_codecrO UnicodeEncodeErrorUTF8r
r! )rE r> r rF Z
input_charsetZoutput_charsetr r r r! s$
z
Header.appendc C s |j p|dkS )N()\)r\ r] r^ )r$ )rE r> r r r rP 4 s zHeader._nonctext;, r c C s | j |d kr| j}|dkr"d}t| j|| j|}d }d }}x4| jD ](\}} |d k r|ol| j|d }|d kr| s| d
kr|j n| d kr| r|j |o| j|d }| }d}|j }
|
r|j d|
d | n|j dd| xr|
dd D ]b} |j
| j d k r,|j | jd| j | n.| j } | d t
| t
| }
|j |
| | qW t
|
dkrJ|j
qJW | jr|j |j|}tj|rtdj||S )
Nr i@B us-asciir Fr r z8header value appears to contain an embedded header: {!r})Nr` )Nr` )Nr` rL )rM rC _ValueFormatterrD rA r
rP add_transitionr feednewlineheader_encodingr r( _str_embedded_headerr r format)rE
splitcharsr9 linesepZ formatterrT rV rU r r linesr1 Zslinefwsvaluer r r rO 9 sR !
z
Header.encodec C s| g }d }g }xL| j D ]B\}}||kr0|j| q|d k rL|jtj||f |g}|}qW |rr|jtj||f || _ d S )N)r
r! rQ rS )rE Zchunksr8 Z
last_chunkr r r r r rM s zHeader._normalize)NNNNr r? )Nr? )r_ Nr )
__name__
__module__ __qualname__rG rW rY r! rP rO rM r r r r r s
-
+
Pc @ sT e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dS )ra c C s0 || _ || _t|| _|| _g | _t|| _d S )N)_maxlenrA r( _continuation_ws_len _splitchars_lines _Accumulator
_current_line)rE Z headerlenmaxlenr; ri r r r rG s
z_ValueFormatter.__init__c C s | j |j| jS )N)rd rS rt )rE rj r r r rf s z_ValueFormatter._strc C s
| j tS )N)rf NL)rE r r r rW s z_ValueFormatter.__str__c C sp | j j }|dkr | j j| t| j dkrb| j j rP| jd t| j 7 < n| jjt| j | j j d S )Nr r r r )r r rL ) rv r pushr( is_onlywsrt r r! reset)rE Z end_of_liner r r rd s
z_ValueFormatter.newlinec C s | j jdd d S )Nr r )rv ry )rE r r r rb s z _ValueFormatter.add_transitionc C s |j d kr | j||| j d S |j|| j }y|jd}W n tk
rP d S X |d k rf| j|| y |j }W n tk
r d S X | j | j j
| j | x |D ]}| j j
| j | qW d S )Nr )re _ascii_splitrs Zheader_encode_lines _maxlengthsr
IndexError
_append_chunkrd rv ry rA rt r! )rE rl r r Z
encoded_linesZ
first_line last_liner1 r r r rc s$
z_ValueFormatter.feedc c s* | j t| j V x| j | j V qW d S )N)rq r( rv rr )rE r r r r} s z_ValueFormatter._maxlengthsc C sj t jdt d || }|d r0dg|d d< n
|jd x*tt|gd D ]\}}| j|| qNW d S )Nz([z]+)r r r )rer FWSr zipiterr )rE rl r ri r2 partr r r r| s
z _ValueFormatter._ascii_splitc C s
| j j|| t| j | jkrx| jD ]t}xlt| j j d ddD ]P}|j rp| j | d }|rp|d |krpP | j |d d }|rD|d |krDP qDW q(P q(W | j j \}}| j j dkr| j
|sd}| j j|| d S | j j |}| j j
t| j | j j| d S )Nr r r rL rL )rv ry r( rq rs range
part_countr$ r
_initial_sizerd pop_fromrt r! r r{ )rE rl r ZchiZprevpartr Z remainderr r r r s. z _ValueFormatter._append_chunkN) rn ro rp rG rf rW rd rb rc r} r| r r r r r ra s %ra c sj e Zd Zd fdd Zdd ZdddZ fdd Zd
d Zd d
ZdddZ dd Z
fddZ Z S )ru r c s || _ t j d S )N)r superrG )rE Z initial_size) __class__r r rG s z_Accumulator.__init__c C s | j ||f d S )N)r! )rE rl r r r r ry # s z_Accumulator.pushc C s | |d }g | |d < |S )Nr )rE r Zpoppedr r r r & s z_Accumulator.pop_fromc s | j dkrdS t j S )Nr r )r r )r r r )rE )r r r r + s z_Accumulator.popc C s t dd | D | jS )Nc s s" | ]\}}t |t | V qd S )N)r( )r rl r r r r 1 s z'_Accumulator.__len__..)sumr )rE r r r __len__0 s z_Accumulator.__len__c C s t jdd | D S )Nc s s | ]\}}t j||fV qd S )N)rR rS )r rl r r r r r 5 s z'_Accumulator.__str__..)rR rS )rE r r r rW 4 s
z_Accumulator.__str__Nc C s" |d kr g }|| d d < d| _ d S )Nr )r )rE Zstartvalr r r r{ 8 s z_Accumulator.resetc C s | j dko| pt| j S )Nr )r r r$ )rE r r r rz > s z_Accumulator.is_onlywsc s
t j S )N)r r )rE )r r r r A s z_Accumulator.part_count)r )r )N)
rn ro rp rG ry r r r rW r{ rz r
__classcell__r r )r r ru s
ru z )NNr )#__all__r r* Zemail.quoprimimer& Zemail.base64mimeZ email.errorsr r r r< rx rQ r/ ZSPACE8rR rB r r@ r[ compileVERBOSE
IGNORECASE MULTILINEr Zfcrerg r' Z _max_appendr r r ra listru r r r r s>
_
k PK ! דM; ; & __pycache__/_policybase.cpython-36.pycnu [ 3
Ii< @ s d Z ddlZddlmZ ddlmZ ddlmZ dddgZG d d
d
Z d d Z
d
d Z G dd de ej dZ
e G dd de
Ze ZdS )zwPolicy framework for the email package.
Allows fine grained feature control of how the package parses and emits data.
N)header)charset)_has_surrogatesPolicyCompat32compat32c s@ e Zd ZdZ fddZdd Zdd Zdd Zd
d Z Z S ) _PolicyBasea Policy Object basic framework.
This class is useless unless subclassed. A subclass should define
class attributes with defaults for any values that are to be
managed by the Policy object. The constructor will then allow
non-default values to be set for these attributes at instance
creation time. The instance will be callable, taking these same
attributes keyword arguments, and returning a new instance
identical to the called instance except for those values changed
by the keyword arguments. Instances may be added, yielding new
instances with any non-default values from the right hand
operand overriding those in the left hand operand. That is,
A + B == A()
The repr of an instance can be used to reconstruct the object
if and only if the repr of the values can be used to reconstruct
those values.
c sL xF|j D ]:\}}t| |r0tt| j|| q
tdj|| jjq
W dS )zCreate new Policy, possibly overriding some defaults.
See class docstring for a list of overridable attributes.
z*{!r} is an invalid keyword argument for {}N) itemshasattrsuperr __setattr__ TypeErrorformat __class____name__)selfkwnamevalue)r )/usr/lib64/python3.6/email/_policybase.py__init__) s
z_PolicyBase.__init__c C s* dd | j j D }dj| jjdj|S )Nc S s g | ]\}}d j ||qS )z{}={!r})r ).0r r r r r
8 s z(_PolicyBase.__repr__..z{}({})z, )__dict__r r r r join)r argsr r r __repr__7 s z_PolicyBase.__repr__c K sz | j j| j }x$| jj D ]\}}tj||| qW x@|j D ]4\}}t| |sdtdj|| j j tj||| q>W |S )zReturn a new instance with specified attributes changed.
The new instance has the same attribute values as the current object,
except for the changes passed in as keyword arguments.
z*{!r} is an invalid keyword argument for {})
r __new__r r objectr r
r
r r )r r Z newpolicyattrr r r r clone< s
z_PolicyBase.clonec C s, t | |rd}nd}t|j| jj|d S )Nz'{!r} object attribute {!r} is read-onlyz!{!r} object has no attribute {!r})r
AttributeErrorr r r )r r r msgr r r r N s
z_PolicyBase.__setattr__c C s | j f |jS )zNon-default values from right operand override those from left.
The object returned is a new instance of the subclass.
)r! r )r otherr r r __add__U s z_PolicyBase.__add__)
r
__module__ __qualname____doc__r r r! r r%
__classcell__r r )r r r s r c C s, | j ddd } |jddd }| d | S )N
r )rsplitsplit)docZ added_docr r r _append_doc^ s r/ c C s | j r(| j jdr(t| jd j | j | _ xf| jj D ]X\}}|j r4|j jdr4xh s z%_extend_docstrings..r( )r(
startswithr/ __bases__r r getattr)clsr r r3 r. r r r _extend_docstringsc s
r9 c @ s e Zd ZdZdZdZdZdZdZdZ dZ
dd Z d
d Z d d
Z
ejdd Zejdd Zejdd Zejdd Zejdd ZdS )r a
Controls for how messages are interpreted and formatted.
Most of the classes and many of the methods in the email package accept
Policy objects as parameters. A Policy object contains a set of values and
functions that control how input is interpreted and how output is rendered.
For example, the parameter 'raise_on_defect' controls whether or not an RFC
violation results in an error being raised or not, while 'max_line_length'
controls the maximum length of output lines when a Message is serialized.
Any valid attribute may be overridden when a Policy is created by passing
it as a keyword argument to the constructor. Policy objects are immutable,
but a new Policy object can be created with only certain values changed by
calling the Policy instance with keyword arguments. Policy objects can
also be added, producing a new Policy object in which the non-default
attributes set in the right hand operand overwrite those specified in the
left operand.
Settable attributes:
raise_on_defect -- If true, then defects should be raised as errors.
Default: False.
linesep -- string containing the value to use as separation
between output lines. Default '\n'.
cte_type -- Type of allowed content transfer encodings
7bit -- ASCII only
8bit -- Content-Transfer-Encoding: 8bit is allowed
Default: 8bit. Also controls the disposition of
(RFC invalid) binary data in headers; see the
documentation of the binary_fold method.
max_line_length -- maximum length of lines, excluding 'linesep',
during serialization. None or 0 means no line
wrapping is done. Default is 78.
mangle_from_ -- a flag that, when True escapes From_ lines in the
body of the message by putting a `>' in front of
them. This is used when the message is being
serialized by a generator. Default: True.
message_factory -- the class to use to create new message objects.
If the value is None, the default is Message.
verify_generated_headers
-- if true, the generator verifies that each header
they are properly folded, so that a parser won't
treat it as multiple headers, start-of-body, or
part of another header.
This is a check against custom Header & fold()
implementations.
Fr* Z8bitN NTc C s | j r
|| j|| dS )aZ Based on policy, either raise defect or call register_defect.
handle_defect(obj, defect)
defect should be a Defect subclass, but in any case must be an
Exception subclass. obj is the object on which the defect should be
registered if it is not raised. If the raise_on_defect is True, the
defect is raised as an error, otherwise the object and the defect are
passed to register_defect.
This method is intended to be called by parsers that discover defects.
The email package parsers always call it with Defect instances.
N)raise_on_defectregister_defect)r objdefectr r r
handle_defect s zPolicy.handle_defectc C s |j j| dS )a Record 'defect' on 'obj'.
Called by handle_defect if raise_on_defect is False. This method is
part of the Policy API so that Policy subclasses can implement custom
defect handling. The default implementation calls the append method of
the defects attribute of obj. The objects used by the email package by
default that get passed to this method will always have a defects
attribute with an append method.
N)Zdefectsappend)r r= r> r r r r< s zPolicy.register_defectc C s dS )a[ Return the maximum allowed number of headers named 'name'.
Called when a header is added to a Message object. If the returned
value is not 0 or None, and there are already a number of headers with
the name 'name' equal to the value returned, a ValueError is raised.
Because the default behavior of Message's __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.)
The default implementation returns None for all header names.
Nr )r r r r r header_max_count s zPolicy.header_max_countc C s t dS )aZ Given a list of linesep terminated strings constituting the lines of
a single header, return the (name, value) tuple that should be stored
in the model. The input lines should retain their terminating linesep
characters. The lines passed in by the email package may contain
surrogateescaped binary data.
N)NotImplementedError)r sourcelinesr r r header_source_parse s zPolicy.header_source_parsec C s t dS )zGiven the header name and the value provided by the application
program, return the (name, value) that should be stored in the model.
N)rB )r r r r r r header_store_parse s zPolicy.header_store_parsec C s t dS )aw Given the header name and the value from the model, return the value
to be returned to the application program that is requesting that
header. The value passed in by the email package may contain
surrogateescaped binary data if the lines were parsed by a BytesParser.
The returned value should not contain any surrogateescaped data.
N)rB )r r r r r r header_fetch_parse s zPolicy.header_fetch_parsec C s t dS )a Given the header name and the value from the model, return a string
containing linesep characters that implement the folding of the header
according to the policy controls. The value passed in by the email
package may contain surrogateescaped binary data if the lines were
parsed by a BytesParser. The returned value should not contain any
surrogateescaped data.
N)rB )r r r r r r fold s
z Policy.foldc C s t dS )a% Given the header name and the value from the model, return binary
data containing linesep characters that implement the folding of the
header according to the policy controls. The value passed in by the
email package may contain surrogateescaped binary data.
N)rB )r r r r r r fold_binary s zPolicy.fold_binary)r r& r' r( r; linesepcte_typemax_line_length mangle_from_Zmessage_factoryZverify_generated_headersr? r< rA abcabstractmethodrD rE rF rG rH r r r r r p s 7
) metaclassc @ sL e Zd ZdZdZdd Zdd Zdd Zd d
Zd d Z d
d Z
dd Z dS )r z+
This particular policy is the backward compatibility Policy. It
replicates the behavior of the email package version 5.1.
Tc C s0 t |ts|S t|r(tj|tj|dS |S d S )N)r header_name)
isinstancestrr r Header_charset UNKNOWN8BIT)r r r r r r _sanitize_header! s
zCompat32._sanitize_headerc C s> |d j dd\}}|jddj|dd }||jdfS )a: +
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.
r :r+ z Nz
)r- lstripr rstrip)r rC r r r r r rD - s z Compat32.header_source_parsec C s ||fS )z>+
The name and value are returned unmodified.
r )r r r r r r rE 9 s zCompat32.header_store_parsec C s | j ||S )z+
If the value contains binary data, it is converted into a Header object
using the unknown-8bit charset. Otherwise it is returned unmodified.
)rV )r r r r r r rF ? s zCompat32.header_fetch_parsec C s | j ||ddS )a +
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 charset.
T)sanitize)_fold)r r r r r r rG F s z
Compat32.foldc C s" | j ||| jdkd}|jddS )a +
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. If 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/or binary data.
Z7bit)r[ asciisurrogateescape)r\ rJ encode)r r r Zfoldedr r r rH P s zCompat32.fold_binaryc C s g }|j d| t|tr\t|rL|r s L
( fPK ! ZqZ) Z) 5 __pycache__/_header_value_parser.cpython-36.opt-1.pycnu [ 3
Ii @ sz d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z ddl m Z ddl m
Z
ed Zeed
B Zed ZeeB Zeed Zeed
ZeedB ed ZeeB ZeedB ZeeB Zeed ZddhZeeB Zdd Z G dd de Z G dd de Z G dd de Z G dd d e Z!G d d d e Z"G d d d e Z#G d!d" d"e Z$G d#d$ d$e Z%G d%d& d&e Z&G d'd( d(e Z'G d)d* d*e'Z(G d+d, d,e Z)G d-d. d.e Z*G d/d0 d0e Z+G d1d2 d2e Z,G d3d4 d4e Z-G d5d6 d6e Z.G d7d8 d8e Z/G d9d: d:e Z0G d;d< d d>e Z2G d?d@ d@e Z3G dAdB dBe Z4G dCdD dDe Z5G dEdF dFe Z6G dGdH dHe Z7G dIdJ dJe Z8G dKdL dLe!Z9G dMdN dNe Z:G dOdP dPe Z;G dQdR dRe ZG dWdX dXe Z?G dYdZ dZe Z@G d[d\ d\e ZAG d]d^ d^e ZBG d_d` d`e ZCG dadb dbeCZDG dcdd ddeCZEG dedf dfe ZFG dgdh dhe ZGG didj dje ZHG dkdl dleIZJG dmdn dneJZKG dodp dpeJZLG dqdr dreKZMeLd dsZNeLdtduZOeLdvdwZPejQdxjRdyjSejTZUejQdzjRdyjSejVd{d|jVd}d~jWZXejQdjYZZejQdzjRdyjSejVd{d|jVd}d~jWZ[ejQdzjRdyjSejVd{d|jVd}d~jWZ\ejQdzjRdyjSejVd{d|jVd}d~jWZ]dd Z^dd Z_dd Z`dd Zadd Zbdd Zcdd Zddd Zedd Zfdd Zgdd Zhdd Zidd Zjdd Zkdd Zldd Zmdd Zndd Zodd Zpdd Zqdd Zrdd Zsdd Ztdd Zudd Zvdd Zwdd Zxdd Zydd Zzdd Z{dd Z|dd Z}dd Z~ddÄ Zddń ZddDŽ ZddɄ Zdd˄ Zdd̈́ Zddτ Zddф Zddӄ ZddՄ Zddׄ Zddل Zddۄ Zdd݄ Zdd߄ Zdd Zdd Zdd Zdd Zdd Zdd Zdd ZdS )al Header value parser implementing various email-related RFC parsing rules.
The parsing methods defined in this module implement various email related
parsing rules. Principal among them is RFC 5322, which is the followon
to RFC 2822 and primarily a clarification of the former. It also implements
RFC 2047 encoded word decoding.
RFC 5322 goes to considerable trouble to maintain backward compatibility with
RFC 822 in the parse phase, while cleaning up the structure on the generation
phase. This parser supports correct RFC 5322 generation by tagging white space
as folding white space only when folding is allowed in the non-obsolete rule
sets. Actually, the parser is even more generous when accepting input than RFC
5322 mandates, following the spirit of Postel's Law, which RFC 5322 encourages.
Where possible deviations from the standard are annotated on the 'defects'
attribute of tokens that deviate.
The general structure of the parser follows RFC 5322, and uses its terminology
where there is a direct correspondence. Where the implementation requires a
somewhat different structure than that used by the formal grammar, new terms
that mimic the closest existing terms are used. Thus, it really helps to have
a copy of RFC 5322 handy when studying this code.
Input to the parser is a string that has already been unfolded according to
RFC 5322 rules. According to the RFC this unfolding is the very first step, and
this parser leaves the unfolding step to a higher level message parser, which
will have already detected the line breaks that need unfolding while
determining the beginning and end of each header.
The output of the parser is a TokenList object, which is a list subclass. A
TokenList is a recursive data structure. The terminal nodes of the structure
are Terminal objects, which are subclasses of str. These do not correspond
directly to terminal objects in the formal grammar, but are instead more
practical higher level combinations of true terminals.
All TokenList and Terminal objects have a 'value' attribute, which produces the
semantically meaningful value of that part of the parse subtree. The value of
all whitespace tokens (no matter how many sub-tokens they may contain) is a
single space, as per the RFC rules. This includes 'CFWS', which is herein
included in the general class of whitespace tokens. There is one exception to
the rule that whitespace tokens are collapsed into single spaces in values: in
the value of a 'bare-quoted-string' (a quoted-string with no leading or
trailing whitespace), any whitespace that appeared between the quotation marks
is preserved in the returned value. Note that in all Terminal strings quoted
pairs are turned into their unquoted values.
All TokenList and Terminal objects also have a string value, which attempts to
be a "canonical" representation of the RFC-compliant form of the substring that
produced the parsed subtree, including minimal use of quoted pair quoting.
Whitespace runs are not collapsed.
Comment tokens also have a 'content' attribute providing the string found
between the parens (including any nested comments) with whitespace preserved.
All TokenList and Terminal objects have a 'defects' attribute which is a
possibly empty list all of the defects found while creating the token. Defects
may appear on any token in the tree, and a composite list of all defects in the
subtree is available through the 'all_defects' attribute of any node. (For
Terminal notes x.defects == x.all_defects.)
Each object in a parse tree is called a 'token', and each has a 'token_type'
attribute that gives the name from the RFC 5322 grammar that it represents.
Not all RFC 5322 nodes are produced, and there is one non-RFC 5322 node that
may be produced: 'ptext'. A 'ptext' is a string of printable ascii characters.
It is returned in place of lists of (ctext/quoted-pair) and
(qtext/quoted-pair).
XXX: provide complete list of token types.
N) hexdigits) OrderedDict)
itemgetter)_encoded_words)errors)utilsz (z
()<>@,:;.\"[].z."(z/?=z*'%%
c C s dt | jddjdd d S )N"\z\\z\")strreplace)value r 2/usr/lib64/python3.6/email/_header_value_parser.py quote_stringb s r c s e Zd ZdZdZdZ fddZdd Z fddZe d d
Z
e d d Z d
d Z e dd Z
e dd Zdd Zd ddZd ddZd ddZ ZS ) TokenListNTc s t j|| g | _d S )N)super__init__defects)selfargskw) __class__r r r o s zTokenList.__init__c C s dj dd | D S )N c s s | ]}t |V qd S )N)r ).0xr r r t s z$TokenList.__str__..)join)r r r r __str__s s zTokenList.__str__c s dj | jjt j S )Nz{}({}))formatr __name__r __repr__)r )r r r r% v s
zTokenList.__repr__c C s dj dd | D S )Nr c s s | ]}|j r|j V qd S )N)r )r r r r r r | s z"TokenList.value..)r! )r r r r r z s zTokenList.valuec C s t dd | D | jS )Nc s s | ] }|j V qd S )N) all_defects)r r r r r r s z(TokenList.all_defects..)sumr )r r r r r& ~ s zTokenList.all_defectsc C s | d j S )Nr )startswith_fws)r r r r r( s zTokenList.startswith_fwsc C s t dd | D S )zATrue if all top level tokens of this part may be RFC2047 encoded.c s s | ] }|j V qd S )N)
as_ew_allowed)r partr r r r s z*TokenList.as_ew_allowed..)all)r r r r r) s zTokenList.as_ew_allowedc C s" g }x| D ]}|j |j q
W |S )N)extendcomments)r r- tokenr r r r- s
zTokenList.commentsc C s t | |dS )N)policy)_refold_parse_tree)r r/ r r r fold s zTokenList.foldr c C s t | j|d d S )N)indent)printppstr)r r2 r r r pprint s zTokenList.pprintc C s dj | j|dS )Nr )r2 )r! _pp)r r2 r r r r4 s zTokenList.ppstrc c s~ dj || jj| jV x<| D ]4}t|ds<|dj | V q |j|d E d H q W | jrhdj | j}nd}dj ||V d S )Nz{}{}/{}(r6 z* !! invalid element in token list: {!r}z z Defects: {}r z{}){})r# r r$
token_typehasattrr6 r )r r2 r. Zextrar r r r6 s
z
TokenList._pp)r )r )r )r$
__module__ __qualname__r7 syntactic_breakew_combine_allowedr r" r% propertyr r& r( r) r- r1 r5 r4 r6
__classcell__r r )r r r i s
r c @ s$ e Zd Zedd Zedd ZdS )WhiteSpaceTokenListc C s dS )N r )r r r r r s zWhiteSpaceTokenList.valuec C s dd | D S )Nc S s g | ]}|j d kr|jqS )comment)r7 content)r r r r r
s z0WhiteSpaceTokenList.comments..r )r r r r r- s z WhiteSpaceTokenList.commentsN)r$ r9 r: r= r r- r r r r r? s r? c @ s e Zd ZdZdS )UnstructuredTokenList unstructuredN)r$ r9 r: r7 r r r r rD s rD c @ s e Zd ZdZdS )PhrasephraseN)r$ r9 r: r7 r r r r rF s rF c @ s e Zd ZdZdS )WordZwordN)r$ r9 r: r7 r r r r rH s rH c @ s e Zd ZdZdS )CFWSListcfwsN)r$ r9 r: r7 r r r r rI s rI c @ s e Zd ZdZdS )AtomatomN)r$ r9 r: r7 r r r r rK s rK c @ s e Zd ZdZdZdS )Tokenr. FN)r$ r9 r: r7 Z encode_as_ewr r r r rM s rM c @ s e Zd ZdZdZdZdZdS ) EncodedWordz encoded-wordN)r$ r9 r: r7 ctecharsetlangr r r r rN s rN c @ s4 e Zd ZdZedd Zedd Zedd ZdS ) QuotedStringz
quoted-stringc C s" x | D ]}|j dkr|jS qW d S )Nzbare-quoted-string)r7 r )r r r r r rB s
zQuotedString.contentc C sB g }x2| D ]*}|j dkr(|jt| q
|j|j q
W dj|S )Nzbare-quoted-stringr )r7 appendr r r! )r resr r r r quoted_value s
zQuotedString.quoted_valuec C s" x | D ]}|j dkr|jS qW d S )Nzbare-quoted-string)r7 r )r r. r r r stripped_value s
zQuotedString.stripped_valueN)r$ r9 r: r7 r= rB rU rV r r r r rR s
rR c @ s$ e Zd ZdZdd Zedd ZdS )BareQuotedStringzbare-quoted-stringc C s t djdd | D S )Nr c s s | ]}t |V qd S )N)r )r r r r r r s z+BareQuotedString.__str__..)r r! )r r r r r" s zBareQuotedString.__str__c C s dj dd | D S )Nr c s s | ]}t |V qd S )N)r )r r r r r r s z)BareQuotedString.value..)r! )r r r r r s zBareQuotedString.valueN)r$ r9 r: r7 r" r= r r r r r rW s rW c @ s8 e Zd ZdZdd Zdd Zedd Zedd Zd
S ) CommentrA c s( dj tdg fdd D dggg S )Nr r c s g | ]} j |qS r )quote)r r )r r r rC s z#Comment.__str__..))r! r' )r r )r r r" s
zComment.__str__c C s2 |j dkrt|S t|jddjddjddS )NrA r z\\r z\(rZ z\))r7 r r )r r r r r rY s
z
Comment.quotec C s dj dd | D S )Nr c s s | ]}t |V qd S )N)r )r r r r r r s z"Comment.content..)r! )r r r r rB s zComment.contentc C s | j gS )N)rB )r r r r r- s zComment.commentsN) r$ r9 r: r7 r" rY r= rB r- r r r r rX s
rX c @ s4 e Zd ZdZedd Zedd Zedd ZdS ) AddressListz address-listc C s dd | D S )Nc S s g | ]}|j d kr|qS )address)r7 )r r r r r rC $ s z)AddressList.addresses..r )r r r r addresses" s zAddressList.addressesc C s t dd | D g S )Nc s s | ]}|j d kr|jV qdS )r\ N)r7 mailboxes)r r r r r r ( s z(AddressList.mailboxes..)r' )r r r r r^ & s zAddressList.mailboxesc C s t dd | D g S )Nc s s | ]}|j d kr|jV qdS )r\ N)r7
all_mailboxes)r r r r r r - s z,AddressList.all_mailboxes..)r' )r r r r r_ + s zAddressList.all_mailboxesN)r$ r9 r: r7 r= r] r^ r_ r r r r r[ s r[ c @ s4 e Zd ZdZedd Zedd Zedd ZdS ) Addressr\ c C s | d j dkr| d jS d S )Nr group)r7 display_name)r r r r rb 5 s zAddress.display_namec C s4 | d j dkr| d gS | d j dkr*g S | d jS )Nr mailboxzinvalid-mailbox)r7 r^ )r r r r r^ : s
zAddress.mailboxesc C s: | d j dkr| d gS | d j dkr0| d gS | d jS )Nr rc zinvalid-mailbox)r7 r_ )r r r r r_ B s
zAddress.all_mailboxesN)r$ r9 r: r7 r= rb r^ r_ r r r r r` 1 s r` c @ s( e Zd ZdZedd Zedd ZdS ) MailboxListz mailbox-listc C s dd | D S )Nc S s g | ]}|j d kr|qS )rc )r7 )r r r r r rC P s z)MailboxList.mailboxes..r )r r r r r^ N s zMailboxList.mailboxesc C s dd | D S )Nc S s g | ]}|j dkr|qS )rc invalid-mailbox)rc re )r7 )r r r r r rC T s z-MailboxList.all_mailboxes..r )r r r r r_ R s zMailboxList.all_mailboxesN)r$ r9 r: r7 r= r^ r_ r r r r rd J s rd c @ s( e Zd ZdZedd Zedd ZdS ) GroupListz
group-listc C s" | s| d j dkrg S | d jS )Nr z mailbox-list)r7 r^ )r r r r r^ \ s zGroupList.mailboxesc C s" | s| d j dkrg S | d jS )Nr z mailbox-list)r7 r_ )r r r r r_ b s zGroupList.all_mailboxesN)r$ r9 r: r7 r= r^ r_ r r r r rf X s rf c @ s4 e Zd ZdZedd Zedd Zedd ZdS ) Groupra c C s | d j dkrg S | d jS )N z
group-list)r7 r^ )r r r r r^ m s zGroup.mailboxesc C s | d j dkrg S | d jS )Nrh z
group-list)r7 r_ )r r r r r_ s s zGroup.all_mailboxesc C s
| d j S )Nr )rb )r r r r rb y s zGroup.display_nameN)r$ r9 r: r7 r= r^ r_ rb r r r r rg i s rg c @ sL e Zd ZdZedd Zedd Zedd Zedd Zed
d Z d S )
NameAddrz name-addrc C s t | dkrd S | d jS )N r )lenrb )r r r r rb s zNameAddr.display_namec C s
| d j S )Nrj )
local_part)r r r r rm s zNameAddr.local_partc C s
| d j S )Nrj rl )domain)r r r r rn s zNameAddr.domainc C s
| d j S )Nrj rl )route)r r r r ro s zNameAddr.routec C s
| d j S )Nrj rl ) addr_spec)r r r r rp s zNameAddr.addr_specN)
r$ r9 r: r7 r= rb rm rn ro rp r r r r ri ~ s ri c @ s@ e Zd ZdZedd Zedd Zedd Zedd Zd
S ) AngleAddrz
angle-addrc C s" x | D ]}|j dkr|jS qW d S )Nz addr-spec)r7 rm )r r r r r rm s
zAngleAddr.local_partc C s" x | D ]}|j dkr|jS qW d S )Nz addr-spec)r7 rn )r r r r r rn s
zAngleAddr.domainc C s" x | D ]}|j dkr|jS qW d S )Nz obs-route)r7 domains)r r r r r ro s
zAngleAddr.routec C s< x6| D ]*}|j dkr|jr |jS t|j|j S qW dS d S )Nz addr-specz<>)r7 rm rp r )r r r r r rp s
zAngleAddr.addr_specN) r$ r9 r: r7 r= rm rn ro rp r r r r rq s
rq c @ s e Zd ZdZedd ZdS )ObsRoutez obs-routec C s dd | D S )Nc S s g | ]}|j d kr|jqS )rn )r7 rn )r r r r r rC s z$ObsRoute.domains..r )r r r r rr s zObsRoute.domainsN)r$ r9 r: r7 r= rr r r r r rs s rs c @ sL e Zd ZdZedd Zedd Zedd Zedd Zed
d Z d S )
Mailboxrc c C s | d j dkr| d jS d S )Nr z name-addr)r7 rb )r r r r rb s zMailbox.display_namec C s
| d j S )Nr )rm )r r r r rm s zMailbox.local_partc C s
| d j S )Nr )rn )r r r r rn s zMailbox.domainc C s | d j dkr| d jS d S )Nr z name-addr)r7 ro )r r r r ro s z
Mailbox.routec C s
| d j S )Nr )rp )r r r r rp s zMailbox.addr_specN)
r$ r9 r: r7 r= rb rm rn ro rp r r r r rt s rt c @ s, e Zd ZdZedd Ze Z Z ZZ dS )InvalidMailboxzinvalid-mailboxc C s d S )Nr )r r r r rb s zInvalidMailbox.display_nameN)
r$ r9 r: r7 r= rb rm rn ro rp r r r r ru s ru c s( e Zd ZdZdZe fddZ ZS )Domainrn Fc s dj t jj S )Nr )r! r r split)r )r r r rn s z
Domain.domain)r$ r9 r: r7 r) r= rn r> r r )r r rv s rv c @ s e Zd ZdZdS )DotAtomzdot-atomN)r$ r9 r: r7 r r r r rx s rx c @ s e Zd ZdZdZdS ) DotAtomTextz
dot-atom-textTN)r$ r9 r: r7 r) r r r r ry s ry c @ sD e Zd ZdZdZedd Zedd Zedd Zed d
Z d S ) AddrSpecz addr-specFc C s
| d j S )Nr )rm )r r r r rm s zAddrSpec.local_partc C s t | dk rd S | d jS )N rj rl )rk rn )r r r r rn s zAddrSpec.domainc C s< t | dk r| d jS | d jj | d j | d jj S )Nr{ r rj rh )rk r rstriplstrip)r r r r r s
zAddrSpec.valuec C sL t | j}t|t|t kr*t| j}n| j}| jd k rH|d | j S |S )N@)setrm rk
DOT_ATOM_ENDSr rn )r ZnamesetZlpr r r rp s
zAddrSpec.addr_specN)
r$ r9 r: r7 r) r= rm rn r rp r r r r rz s rz c @ s e Zd ZdZdZdS ) ObsLocalPartzobs-local-partFN)r$ r9 r: r7 r) r r r r r s r c s4 e Zd ZdZdZedd Ze fddZ ZS ) DisplayNamez display-nameFc C s t | }|d jdkr"|jd n*|d d jdkrLt |d dd |d< |d jdkrd|j n*|d d jdkrt |d d d |d < |jS )
Nr rJ rj rl rl rl rl rl rl )r r7 popr )r rT r r r rb + s
zDisplayName.display_namec s d}| j rd}n x| D ]}|jdkrd}qW |rd }}| d jdksX| d d jdkr\d}| d jdks|| d
d jdkrd}|t| j | S t jS d S ) NFTz
quoted-stringr r rJ r@ rj rl rl rl )r r7 r rb r r )r rY r ZpreZpost)r r r r : s
zDisplayName.value) r$ r9 r: r7 r< r= rb r r> r r )r r r & s r c @ s, e Zd ZdZdZedd Zedd ZdS ) LocalPartz
local-partFc C s& | d j dkr| d jS | d jS d S )Nr z
quoted-string)r7 rU r )r r r r r S s
zLocalPart.valuec C s t g}t }d}x| d t g D ]}|jdkr.q |r^|jdkr^|d jdkr^t|d d |d< t|t}|r|jdkr|d jdkr|jt|dd n
|j| |d }|}q W t|dd
}|jS ) NFr rJ dotrj rl rl rl rl rl )DOTr7 r
isinstancerS r )r rT ZlastZ
last_is_tltokZis_tlr r r rm Z s$
zLocalPart.local_partN)r$ r9 r: r7 r) r= r rm r r r r r N s r c s4 e Zd ZdZdZe fddZedd Z ZS )
DomainLiteralzdomain-literalFc s dj t jj S )Nr )r! r r rw )r )r r r rn w s zDomainLiteral.domainc C s" x | D ]}|j dkr|jS qW d S )Nptext)r7 r )r r r r r ip{ s
zDomainLiteral.ip) r$ r9 r: r7 r) r= rn r r> r r )r r r r s r c @ s e Zd ZdZdZdZdS ) MIMEVersionz mime-versionN)r$ r9 r: r7 majorminorr r r r r s r c @ s4 e Zd ZdZdZdZdZedd Zedd Z dS ) Parameter parameterFzus-asciic C s | j r| d jS dS )Nrj r ) sectionednumber)r r r r section_number s zParameter.section_numberc C sb x\| D ]T}|j dkr|jS |j dkrx4|D ],}|j dkr*x |D ]}|j dkr>|jS q>W q*W qW dS )Nr z
quoted-stringzbare-quoted-stringr )r7 rV )r r. r r r param_value s
zParameter.param_valueN)
r$ r9 r: r7 r extendedrP r= r r r r r r r s r c @ s e Zd ZdZdS )InvalidParameterzinvalid-parameterN)r$ r9 r: r7 r r r r r s r c @ s e Zd ZdZedd ZdS ) Attribute attributec C s$ x | D ]}|j jdr|jS qW d S )Nattrtext)r7 endswithr )r r. r r r rV s
zAttribute.stripped_valueN)r$ r9 r: r7 r= rV r r r r r s r c @ s e Zd ZdZdZdS )SectionsectionN)r$ r9 r: r7 r r r r r r s r c @ s e Zd ZdZedd ZdS )Valuer c C s2 | d }|j dkr| d }|j jdr,|jS | jS )Nr rJ rj
quoted-stringr extended-attribute)r r r )r7 r rV r )r r. r r r rV s
zValue.stripped_valueN)r$ r9 r: r7 r= rV r r r r r s r c @ s( e Zd ZdZdZedd Zdd ZdS )MimeParameterszmime-parametersFc c s t }x\| D ]T}|jjds q |d jdkr.q |d jj }||krLg ||< || j|j|f q W x|j D ]\}}t|t dd}|d d }|j
}|j rt |dkr|d d dkr|d d j
jtjd |d d }g }d}x|D ]\} }
| |kr6|
j s$|
j
jtjd qn|
j
jtjd |d7 }|
j} |
j rytjj| } W n& tk
r tjj| d d
} Y nRX y| j|d } W n" tk
r | jd d } Y nX tj| r|
j
jtj |j| qW d
j|} || fV qpW d S )Nr r r )keyrj z.duplicate parameter name; duplicate(s) ignoredz+duplicate parameter name; duplicate ignoredz(inconsistent RFC2231 parameter numberingzlatin-1)encodingsurrogateescapezus-asciir ) r r7 r r striprS r itemssortedr rP r rk r r InvalidHeaderDefectr urllibparseZunquote_to_bytesUnicodeEncodeErrorZunquotedecode LookupErrorr _has_surrogatesUndecodableBytesDefectr! ) r paramsr. namepartsZ first_paramrP Z value_partsir paramr r r r r sZ
zMimeParameters.paramsc C sX g }x8| j D ].\}}|r0|jdj|t| q |j| q W dj|}|rTd| S dS )Nz{}={}z; r@ r )r rS r# r r! )r r r r r r r r" s
zMimeParameters.__str__N)r$ r9 r: r7 r; r= r r" r r r r r s Fr c @ s e Zd ZdZedd ZdS )ParameterizedHeaderValueFc C s& x t | D ]}|jdkr
|jS q
W i S )Nzmime-parameters)reversedr7 r )r r. r r r r % s
z ParameterizedHeaderValue.paramsN)r$ r9 r: r; r= r r r r r r s r c @ s e Zd ZdZdZdZdZdS ) ContentTypez content-typeFtextZplainN)r$ r9 r: r7 r) maintypesubtyper r r r r - s r c @ s e Zd ZdZdZdZdS )ContentDispositionzcontent-dispositionFN)r$ r9 r: r7 r) content_dispositionr r r r r 5 s r c @ s e Zd ZdZdZdZdS )ContentTransferEncodingzcontent-transfer-encodingFZ7bitN)r$ r9 r: r7 r) rO r r r r r < s r c @ s e Zd ZdZdZdS ) HeaderLabelz header-labelFN)r$ r9 r: r7 r) r r r r r C s r c @ s e Zd ZdZdS )HeaderheaderN)r$ r9 r: r7 r r r r r I s r c sr e Zd ZdZdZdZ fddZ fddZdd Ze dd Z
d fd d Z d
d Z e dd Z
dd Z ZS )TerminalTc s t j| |}||_g |_|S )N)r __new__r7 r )clsr r7 r )r r r r X s zTerminal.__new__c s dj | jjt j S )Nz{}({}))r# r r$ r r% )r )r r r r% ^ s zTerminal.__repr__c C s t | jjd | j d S )N/)r3 r r$ r7 )r r r r r5 a s zTerminal.pprintc C s
t | jS )N)listr )r r r r r& d s zTerminal.all_defectsr c s2 dj || jj| jt j | js"dn
dj | jgS )Nz
{}{}/{}({}){}r z {})r# r r$ r7 r r% r )r r2 )r r r r6 h s z Terminal._ppc C s d S )Nr )r r r r pop_trailing_wsq s zTerminal.pop_trailing_wsc C s g S )Nr )r r r r r- u s zTerminal.commentsc C s t | | jfS )N)r r7 )r r r r __getnewargs__y s zTerminal.__getnewargs__)r )r$ r9 r: r) r< r; r r% r5 r= r& r6 r r- r r> r r )r r r R s r c @ s e Zd Zedd Zdd ZdS )WhiteSpaceTerminalc C s dS )Nr@ r )r r r r r s zWhiteSpaceTerminal.valuec C s dS )NTr )r r r r r( s z!WhiteSpaceTerminal.startswith_fwsN)r$ r9 r: r= r r( r r r r r } s r c @ s e Zd Zedd Zdd ZdS )
ValueTerminalc C s | S )Nr )r r r r r s zValueTerminal.valuec C s dS )NFr )r r r r r( s z ValueTerminal.startswith_fwsN)r$ r9 r: r= r r( r r r r r s r c @ s e Zd Zedd Zdd ZdS )EWWhiteSpaceTerminalc C s dS )Nr r )r r r r r s zEWWhiteSpaceTerminal.valuec C s dS )Nr r )r r r r r" s z EWWhiteSpaceTerminal.__str__N)r$ r9 r: r= r r" r r r r r s r r ,zlist-separatorr~ zroute-component-markerz([{}]+)r z[^{}]+r z\\]z\]z[\x00-\x20\x7F]c C s> t | }|r | jjtj| tj| r:| jjtjd dS )z@If input token contains ASCII non-printables, register a defect.z*Non-ASCII characters found in header tokenN)_non_printable_finderr rS r ZNonPrintableDefectr r r )xtextZnon_printablesr r r _validate_xtext s
r c C s t | d^}}g }d}d}xbtt|D ]J}|| dkrL|rFd}d}nd}q(|rVd}n|| |krdP |j|| q(W |d }dj|dj||d g| |fS )ak Scan printables/quoted-pairs until endchars and return unquoted ptext.
This function turns a run of qcontent, ccontent-without-comments, or
dtext-with-quoted-printables into a single string by unquoting any
quoted printables. It returns the string, the remaining value, and
a flag that is True iff there were any quoted printables decoded.
rj Fr Tr N)
_wsp_splitterrangerk rS r! )r endcharsZfragment remainderZvcharsescapehad_qpposr r r _get_ptext_to_endchars s$ r c C s. | j }t| dt| t| d}||fS )zFWS = 1*WSP
This isn't the RFC definition. We're using fws to represent tokens where
folding can be done, but when we are parsing the *un*folding has already
been done so we don't need to watch out for CRLF.
Nfws)r} r rk )r Znewvaluer r r r get_fws s r c
C s t }| jds tjdj| | dd jdd^}}|| dd krXtjdj| dj|}t|dkr|d tkr|d tkr|jdd^}}|d | }t|j dkr|j j
tj d | |_ dj|} y t
jd| d \}}}} W n( tk
r tjd
j|j Y nX ||_||_|j j| xh|r|d tkrdt|\}
}|j
|
q6t|d^} }t| d } t| |j
| dj|}q6W || fS ) zE encoded-word = "=?" charset "?" encoding "?" encoded-text "?="
z=?z"expected encoded word but found {}rh Nz?=rj r r z whitespace inside encoded wordz!encoded word format invalid: '{}'vtext)rN
startswithr HeaderParseErrorr# rw r! rk r r rS r rO _ewr
ValueErrorrP rQ r, WSPr r r r )
r ewr r Zremstrrestr rP rQ r r. charsr r r r get_encoded_word sH
$
r c C s t }x| r | d tkr4t| \}} |j| q
| jdryt| \}} W n tjk
rd Y nrX d}t|dkr|d j dkr|j
jtj d d}|rt|dkr|d
j d krt |d d|d< |j| q
t
| d^}}t|d
}t| |j| d j|} q
W |S )aO unstructured = (*([FWS] vchar) *WSP) / obs-unstruct
obs-unstruct = *((*LF *CR *(obs-utext) *LF *CR)) / FWS)
obs-utext = %d0 / obs-NO-WS-CTL / LF / CR
obs-NO-WS-CTL is control characters except WSP/CR/LF.
So, basically, we have printable runs, plus control characters or nulls in
the obsolete syntax, separated by whitespace. Since RFC 2047 uses the
obsolete syntax in its specification, but requires whitespace on either
side of the encoded words, I can see no reason to need to separate the
non-printable-non-whitespace from the printable runs if they occur, so we
parse this into xtext tokens separated by WSP tokens.
Because an 'unstructured' value must by definition constitute the entire
value, this 'get' routine does not return a remaining value, only the
parsed TokenList.
r z=?Trj r z&missing whitespace before encoded wordFrh z encoded-wordr r rl rl rl )rD r r rS r r r r rk r7 r r r r r r r! )r rE r. Zhave_wsr r r r r r get_unstructured! s:
r c C s* t | d\}} }t|d}t| || fS )a ctext =
This is not the RFC ctext, since we are handling nested comments in comment
and unquoting quoted-pairs here. We allow anything except the '()'
characters, but if we find any ASCII other than the RFC defined printable
ASCII, a NonPrintableDefect is added to the token's defects list. Since
quoted pairs are converted to their unquoted values, what is returned is
a 'ptext' token. In this case it is a WhiteSpaceTerminal, so it's value
is ' '.
z()r )r r r )r r _r r r get_qp_ctextY s
r c C s* t | d\}} }t|d}t| || fS )ao qcontent = qtext / quoted-pair
We allow anything except the DQUOTE character, but if we find any ASCII
other than the RFC defined printable ASCII, a NonPrintableDefect is
added to the token's defects list. Any quoted pairs are converted to their
unquoted values, so what is returned is a 'ptext' token. In this case it
is a ValueTerminal.
r
r )r r r )r r r r r r get_qcontentj s
r c C sN t | }|s tjdj| |j }| t|d } t|d}t| || fS )zatext =
We allow any non-ATOM_ENDS in atext, but add an InvalidATextDefect to
the token's defects list if we find non-atext characters.
z expected atext but found '{}'Natext)_non_atom_end_matcherr r r# ra rk r r )r mr r r r get_atexty s
r c C s | d dkr t jdj| t }| dd } | d dkrPt| \}} |j| x| r| d dkr| d tkr|t| \}} nd| dd dkry"t| \}} |j jt j
d W q t jk
r t| \}} Y qX n t| \}} |j| qRW | s|j jt j
d || fS || dd fS )
zbare-quoted-string = DQUOTE *([FWS] qcontent) [FWS] DQUOTE
A quoted-string without the leading or trailing white space. Its
value is the text between the quote marks, with whitespace
preserved and quoted pairs decoded.
r r
zexpected '"' but found '{}'rj Nrh z=?z!encoded word inside quoted stringz"end of header inside quoted string) r r r# rW r rS r r r r r )r Zbare_quoted_stringr. r r r get_bare_quoted_string s2
r c C s | r | d dkr t jdj| t }| dd } x^| r| d dkr| d tkr^t| \}} n&| d dkrxt| \}} n t| \}} |j| q4W | s|j jt j
d || fS || dd fS )zcomment = "(" *([FWS] ccontent) [FWS] ")"
ccontent = ctext / quoted-pair / comment
We handle nested comments here, and quoted-pair in our qp-ctext routine.
r r zexpected '(' but found '{}'rj NrZ z end of header inside comment) r r r# rX r r get_commentr rS r r )r rA r. r r r r s"
r c C sT t }xD| rJ| d tkrJ| d tkr2t| \}} n t| \}} |j| qW || fS )z,CFWS = (1*([FWS] comment) [FWS]) / FWS
r )rI CFWS_LEADERr r r rS )r rJ r. r r r get_cfws s r c C sp t }| r,| d tkr,t| \}} |j| t| \}} |j| | rh| d tkrht| \}} |j| || fS )zquoted-string = [CFWS] [CFWS]
'bare-quoted-string' is an intermediate class defined by this
parser and not by the RFC grammar. It is the quoted string
without any attached CFWS.
r )rR r r rS r )r Z
quoted_stringr. r r r get_quoted_string s
r c C s t }| r,| d tkr,t| \}} |j| | rL| d tkrLtjdj| | jdryt | \}} W q tjk
r t
| \}} Y qX n t
| \}} |j| | r| d tkrt| \}} |j| || fS )zPatom = [CFWS] 1*atext [CFWS]
An atom could be an rfc2047 encoded word.
r z expected atom but found '{}'z=?) rK r r rS ATOM_ENDSr r r# r r r )r rL r. r r r get_atom s$
r c C s t }| s| d tkr(tjdj| xP| rx| d tkrxt| \}} |j| | r*| d dkr*|jt | dd } q*W |d tkrtjdjd| || fS )z( dot-text = 1*atext *("." 1*atext)
r z8expected atom at a start of dot-atom-text but found '{}'r rj Nz4expected atom at end of dot-atom-text but found '{}'rl )ry r r r r# r rS r )r Z
dot_atom_textr. r r r get_dot_atom_text s
r c C s t }| d tkr(t| \}} |j| | jdrhyt| \}} W qt tjk
rd t| \}} Y qtX n t| \}} |j| | r| d tkrt| \}} |j| || fS )z dot-atom = [CFWS] dot-atom-text [CFWS]
Any place we can have a dot atom, we could instead have an rfc2047 encoded
word.
r z=?) rx r r rS r r r r r )r Zdot_atomr. r r r get_dot_atom s
r c C s | d t krt| \}} nd}| d dkr8t| \}} n*| d tkrVtjdj| n t| \}} |dk rx|g|dd< || fS )a word = atom / quoted-string
Either atom or quoted-string may start with CFWS. We have to peel off this
CFWS first to determine which type of word to parse. Afterward we splice
the leading CFWS, if any, into the parsed sub-token.
If neither an atom or a quoted-string is found before the next special, a
HeaderParseError is raised.
The token returned is either an Atom or a QuotedString, as appropriate.
This means the 'word' level of the formal grammar is not represented in the
parse tree; this is because having that extra layer when manipulating the
parse tree is more confusing than it is helpful.
r Nr
z1Expected 'atom' or 'quoted-string' but found '{}')r r r SPECIALSr r r# r )r leaderr. r r r get_word* s
r c C s t }yt| \}} |j| W n( tjk
rH |jjtjd Y nX x| r| d tkr| d dkr|jt |jjtj d | dd } qLyt| \}} W nD tjk
r | d t
krt | \}} |jjtj d n Y nX |j| qLW || fS )a phrase = 1*word / obs-phrase
obs-phrase = word *(word / "." / CFWS)
This means a phrase can be a sequence of words, periods, and CFWS in any
order as long as it starts with at least one word. If anything other than
words is detected, an ObsoleteHeaderDefect is added to the token's defect
list. We also accept a phrase that starts with CFWS followed by a dot;
this is registered as an InvalidHeaderDefect, since it is not supported by
even the obsolete grammar.
z phrase does not start with wordr r zperiod in 'phrase'rj Nzcomment found without atom) rF r rS r r r r PHRASE_ENDSr ObsoleteHeaderDefectr r )r rG r. r r r
get_phraseI s.
r c C st t }d}| d tkr"t| \}} | s6tjdj| yt| \}} W n^ tjk
r yt| \}} W n6 tjk
r | d dkr| d tkr t }Y nX Y nX |dk r|g|dd< |j
| | o| d dks| d tkr2t t || \}} |j
dkr|jj
tjd n|jj
tjd ||d< y|jjd W n( tk
rj |jj
tjd Y nX || fS )
z= local-part = dot-atom / quoted-string / obs-local-part
Nr z"expected local-part but found '{}'r zinvalid-obs-local-partz / obs-dtext
obs-dtext = obs-NO-WS-CTL / quoted-pair
We allow anything except the excluded characters, but if we find any
ASCII other than the RFC defined printable ASCII, a NonPrintableDefect is
added to the token's defects list. Quoted pairs are converted to their
unquoted values, so what is returned is a ptext token, in this case a
ValueTerminal. If there were quoted-printables, an ObsoleteHeaderDefect is
added to the returned token's defect list.
z[]r z(quoted printable found in domain-literal)r r r rS r r r )r r r r r r get_dtext s
r c C s, | rdS |j tjd |j tdd dS )NFz"end of input inside domain-literalr zdomain-literal-endT)rS r r r )r domain_literalr r r _check_for_early_dl_end s r c C sl t }| d tkr(t| \}} |j| | s6tjd| d dkrRtjdj| | dd } t| |rp|| fS |jtdd | d t krt
| \}} |j| t | \}} |j| t| |r|| fS | d t krt
| \}} |j| t| |r || fS | d dkr tjd j| |jtdd
| dd } | rd| d tkrdt| \}} |j| || fS ) zB domain-literal = [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
r zexpected domain-literal[z6expected '[' at start of domain-literal but found '{}'rj Nzdomain-literal-startr z4expected ']' at end of domain-literal but found '{}'zdomain-literal-end) r r r rS r r r# r r r r r )r r r. r r r get_domain_literal sD
r c C st t }d}| d tkr"t| \}} | s6tjdj| | d dkrvt| \}} |dk rd|g|dd< |j| || fS yt| \}} W n" tjk
r t | \}} Y nX | r| d dkrtjd|dk r|g|dd< |j| | o| d dkrl|j
jtj d |d j d kr(|d |dd< xB| rj| d dkrj|jt
t | d
d \}} |j| q*W || fS ) z] domain = dot-atom / domain-literal / obs-domain
obs-domain = atom *("." atom))
Nr z expected domain but found '{}'r r~ zInvalid Domainr z(domain is not a dot-atom (contains CFWS)zdot-atomrj )rv r r r r r# r rS r r r r r7 r )r rn r r. r r r
get_domain s@
r c C s~ t }t| \}} |j| | s.| d dkrH|jjtjd || fS |jtdd t| dd \}} |j| || fS )z( addr-spec = local-part "@" domain
r r~ z"add-spec local part with no domainzaddress-at-symbolrj N)rz r rS r r r r r )r rp r. r r r
get_addr_spec. s
r c C s t }xf| rl| d dks$| d tkrl| d tkrHt| \}} |j| q| d dkr|jt | dd } qW | s| d dkrtjdj| |jt t | dd \}} |j| x| o| d dkrB|jt | dd } | sP | d tkr t| \}} |j| | d dkr|jt t | dd \}} |j| qW | sTtjd| d dkrrtjd j| |jt
dd
|| dd fS ) z obs-route = obs-domain-list ":"
obs-domain-list = *(CFWS / ",") "@" domain *("," [CFWS] ["@" domain])
Returns an obs-route token with the appropriate sub-tokens (that is,
there is no obs-domain-list in the parse tree).
r r rj Nr~ z(expected obs-route domain but found '{}'z%end of header while parsing obs-route:z4expected ':' marking end of obs-route but found '{}'zend-of-obs-route-marker) rs r r rS
ListSeparatorr r r# RouteComponentMarkerr r )r Z obs_router. r r r
get_obs_route> sB
r
c C s t }| d tkr(t| \}} |j| | s:| d dkrJtjdj| |jtdd | dd } | d dkr|jtdd |jjtj d | dd } || fS yt
| \}} W nz tjk
r2 y"t | \}} |jjtj d
W n( tjk
r tjd j| Y nX |j| t
| \}} Y nX |j| | r`| d dkr`| dd } n|jjtj d |jtdd | r| d tkrt| \}} |j| || fS )
z angle-addr = [CFWS] "<" addr-spec ">" [CFWS] / obs-angle-addr
obs-angle-addr = [CFWS] "<" obs-route addr-spec ">" [CFWS]
r zangle-addr-endz null addr-spec in angle-addrz*obsolete route specification in angle-addrz.expected addr-spec or obs-route but found '{}'z"missing trailing '>' on angle-addr)
rq r r rS r r r# r r r r r
r )r Z
angle_addrr. r r r get_angle_addrg sJ
r
c C s< t }t| \}} |j|dd |jdd |_|| fS )z display-name = phrase
Because this is simply a name-rule, we don't return a display-name
token containing a phrase, but rather a display-name token with
the content of the phrase.
N)r r r, r )r rb r. r r r get_display_name s
r c C s t }d}| d tkr6t| \}} | s6tjdj|| d dkr| d tkr^tjdj| t| \}} | s~tjdj||dk r|g|d dd< d}|j| t | \}} |dk r|g|dd< |j| || fS )z, name-addr = [display-name] angle-addr
Nr z!expected name-addr but found '{}'r )
ri r r r r r# r r rS r
)r Z name_addrr r. r r r
get_name_addr s0
r c C s t }yt| \}} W nN tjk
rd yt| \}} W n& tjk
r^ tjdj| Y nX Y nX tdd |jD rd|_|j | || fS )z& mailbox = name-addr / addr-spec
z expected mailbox but found '{}'c s s | ]}t |tjV qd S )N)r r r )r r r r r r s z get_mailbox..zinvalid-mailbox)
rt r r r r r# anyr& r7 rS )r rc r. r r r get_mailbox s
r c C sh t }xX| r^| d |kr^| d tkrF|jt| d d | dd } qt| \}} |j| qW || fS )z Read everything up to one of the chars in endchars.
This is outside the formal grammar. The InvalidMailbox TokenList that is
returned acts like a Mailbox, but the data attributes are None.
r zmisplaced-specialrj N)ru r rS r r )r r Zinvalid_mailboxr. r r r get_invalid_mailbox s r c C s t }x| o| d dkry t| \}} |j| W n tjk
r@ d}| d tkrt| \}} | sz| d dkr|j| |jjtjd n@t | d\}} |dk r|g|dd< |j| |jjtj
d nb| d dkr|jjtjd nBt | d\}} |dk r |g|dd< |j| |jjtj
d Y nX | r| d dkr|d
}d |_ t | d\}} |j | |jjtj
d | r
| d dkr
|jt
| dd } q
W || fS ) aJ mailbox-list = (mailbox *("," mailbox)) / obs-mbox-list
obs-mbox-list = *([CFWS] ",") mailbox *("," [mailbox / CFWS])
For this routine we go outside the formal grammar in order to improve error
handling. We recognize the end of the mailbox list only at the end of the
value or at a ';' (the group terminator). This is so that we can turn
invalid mailboxes into InvalidMailbox tokens and continue parsing any
remaining valid mailboxes. We also allow all mailbox entries to be null,
and this condition is handled appropriately at a higher level.
r ;Nz,;z empty element in mailbox-listz invalid mailbox in mailbox-listr rj zinvalid-mailboxrl )rd r rS r r r r r r r r r7 r, r )r Z mailbox_listr. r rc r r r get_mailbox_list sN
r c C s t }| s$|jjtjd || fS d}| r| d tkrt| \}} | sl|jjtjd |j| || fS | d dkr|j| || fS t| \}} t|j dkr|dk r|j| |j
| |jjtj d || fS |dk r|g|dd< |j| || fS )zg group-list = mailbox-list / CFWS / obs-group-list
obs-group-list = 1*([CFWS] ",") [CFWS]
z end of header before group-listNr zend of header in group-listr z group-list with empty entries) rf r rS r r r r r rk r_ r, r )r Z
group_listr r. r r r get_group_list" s8
r c C s" t }t| \}} | s$| d dkr4tjdj| |j| |jtdd | dd } | r| d dkr|jtdd || dd fS t| \}} |j| | s|jjtj d n | d dkrtjd
j| |jtdd | dd } | r| d t
krt | \}} |j| || fS ) z7 group = display-name ":" [group-list] ";" [CFWS]
r r z8expected ':' at end of group display name but found '{}'z group-display-name-terminatorrj Nr zgroup-terminatorzend of header in groupz)expected ';' at end of group but found {}) rg r r r r# rS r r r r r r )r ra r. r r r get_groupG s2
r c C sx t }yt| \}} W nN tjk
rd yt| \}} W n& tjk
r^ tjdj| Y nX Y nX |j| || fS )a address = mailbox / group
Note that counter-intuitively, an address can be either a single address or
a list of addresses (a group). This is why the returned Address object has
a 'mailboxes' attribute which treats a single address as a list of length
one. When you need to differentiate between to two cases, extract the single
element, which is either a mailbox or a group token.
z expected address but found '{}')r` r r r r r# rS )r r\ r. r r r get_addresse s
r c C s t }x| ry t| \}} |j| W n$ tjk
rP } zd}| d tkrt| \}} | sr| d dkr|j| |jjtjd nFt | d\}} |dk r|g|dd< |jt
|g |jjtj d nh| d dkr|jjtjd nHt | d\}} |dk r |g|dd< |jt
|g |jjtj d W Y dd}~X nX | r| d dkr|d
d }d|_ t | d\}} |j
| |jjtj d | r
|jtdd | dd } q
W || fS ) a address_list = (address *("," address)) / obs-addr-list
obs-addr-list = *([CFWS] ",") address *("," [address / CFWS])
We depart from the formal grammar here by continuing to parse until the end
of the input, assuming the input to be entirely composed of an
address-list. This is always true in email parsing, and allows us
to skip invalid addresses to parse additional valid ones.
Nr r z"address-list entry with no contentz invalid address in address-listz empty element in address-listrj zinvalid-mailboxzlist-separatorrl )r[ r rS r r r r r r r r` r r7 r, r )r Z address_listr. errr rc r r r get_address_list sN
r c C s t }| s |jjtjd |S | d tkrXt| \}} |j| | sX|jjtjd d}x8| r| d dkr| d tkr|| d 7 }| dd } q^W |j s|jjtjdj | |jt
|d nt ||_ |jt
|d
| o| d tkr
t| \}} |j| | s | d dkrX|j dk r>|jjtjd | rT|jt
| d |S |jt
dd | dd } | r| d tkrt| \}} |j| | s|j dk r|jjtjd |S d}x2| r| d tkr|| d 7 }| dd } qW |j s2|jjtjd
j | |jt
|d nt ||_
|jt
|d
| rv| d tkrvt| \}} |j| | r|jjtjd |jt
| d |S )zE mime-version = [CFWS] 1*digit [CFWS] "." [CFWS] 1*digit [CFWS]
z%Missing MIME version number (eg: 1.0)r z0Expected MIME version number but found only CFWSr r rj Nz1Expected MIME major version number but found {!r}r digitsz0Incomplete MIME version; found only major numberzversion-separatorz1Expected MIME minor version number but found {!r}z'Excess non-CFWS text after MIME version)r r rS r HeaderMissingRequiredValuer r isdigitr r# r intr r )r Z mime_versionr. r r r r parse_mime_version sv
r c C sh t }xX| r^| d dkr^| d tkrF|jt| d d | dd } qt| \}} |j| qW || fS )z Read everything up to the next ';'.
This is outside the formal grammar. The InvalidParameter TokenList that is
returned acts like a Parameter, but the data attributes are None.
r r zmisplaced-specialrj N)r r rS r r )r Zinvalid_parameterr. r r r get_invalid_parameter s r c C sN t | }|s tjdj| |j }| t|d } t|d}t| || fS )a8 ttext =
We allow any non-TOKEN_ENDS in ttext, but add defects to the token's
defects list if we find non-ttext characters. We also register defects for
*any* non-printables even though the RFC doesn't exclude all of them,
because we follow the spirit of RFC 5322.
z expected ttext but found '{}'Nttext)_non_token_end_matcherr r r# ra rk r r )r r r r r r get_ttext s
r" c C s t }| r,| d tkr,t| \}} |j| | rL| d tkrLtjdj| t| \}} |j| | r| d tkrt| \}} |j| || fS )ztoken = [CFWS] 1*ttext [CFWS]
The RFC equivalent of ttext is any US-ASCII chars except space, ctls, or
tspecials. We also exclude tabs even though the RFC doesn't.
The RFC implies the CFWS but is not explicit about it in the BNF.
r z expected token but found '{}') rM r r rS
TOKEN_ENDSr r r# r" )r Zmtokenr. r r r get_token) s
r$ c C sN t | }|s tjdj| |j }| t|d } t|d}t| || fS )aQ attrtext = 1*(any non-ATTRIBUTE_ENDS character)
We allow any non-ATTRIBUTE_ENDS in attrtext, but add defects to the
token's defects list if we find non-attrtext characters. We also register
defects for *any* non-printables even though the RFC doesn't exclude all of
them, because we follow the spirit of RFC 5322.
z expected attrtext but found {!r}Nr )_non_attribute_end_matcherr r r# ra rk r r )r r r r r r get_attrtext@ s
r& c C s t }| r,| d tkr,t| \}} |j| | rL| d tkrLtjdj| t| \}} |j| | r| d tkrt| \}} |j| || fS )aH [CFWS] 1*attrtext [CFWS]
This version of the BNF makes the CFWS explicit, and as usual we use a
value terminal for the actual run of characters. The RFC equivalent of
attrtext is the token characters, with the subtraction of '*', "'", and '%'.
We include tab in the excluded set just as we do for token.
r z expected token but found '{}') r r r rS ATTRIBUTE_ENDSr r r# r& )r r r. r r r
get_attributeS s
r( c C sN t | }|s tjdj| |j }| t|d } t|d}t| || fS )zattrtext = 1*(any non-ATTRIBUTE_ENDS character plus '%')
This is a special parsing routine so that we get a value that
includes % escapes as a single string (which we decode as a single
string later).
z)expected extended attrtext but found {!r}Nzextended-attrtext)#_non_extended_attribute_end_matcherr r r# ra rk r r )r r r r r r get_extended_attrtextj s
r* c C s t }| r,| d tkr,t| \}} |j| | rL| d tkrLtjdj| t| \}} |j| | r| d tkrt| \}} |j| || fS )z [CFWS] 1*extended_attrtext [CFWS]
This is like the non-extended version except we allow % characters, so that
we can pick up an encoded value as a single string.
r z expected token but found '{}') r r r rS EXTENDED_ATTRIBUTE_ENDSr r r# r* )r r r. r r r get_extended_attribute| s
r, c C s t }| s| d dkr(tjdj| |jtdd | dd } | sX| d j rhtjdj| d}x,| r| d j r|| d 7 }| dd } qnW |d d kr|d kr|jjtjd
t ||_
|jt|d || fS ) a6 '*' digits
The formal BNF is more complicated because leading 0s are not allowed. We
check for that and add a defect. We also assume no CFWS is allowed between
the '*' and the digits, though the RFC is not crystal clear on that.
The caller should already have dealt with leading CFWS.
r *z Expected section but found {}zsection-markerrj Nz$Expected section number but found {}r 0z'section number has an invalid leading 0r ) r r r r# rS r r r ZInvalidHeaderErrorr r )r r r r r r get_section s&
r/ c C s t }| stjdd}| d tkr0t| \}} | sDtjdj|| d dkr^t| \}} n t| \}} |dk r|g|dd< |j| || fS )z quoted-string / attribute
z&Expected value but found end of stringNr z Expected value but found only {}r
) r r r r r r# r r, rS )r vr r. r r r get_value s
r1 c C sv t }t| \}} |j| | s.| d dkrN|jjtjdj| || fS | d dkry t| \}} d|_|j| W n tj k
r Y nX | stj d| d dkr|jt
dd | dd } d|_ | d d
krtj d |jt
d
d | dd } d }| r.| d t kr.t
| \}} |j| d }|}|j rH| rH| d d
krHt| \}}|j}d}|jdkr|r|d dkrd}n$t|\}} | r| d dkrd}n(yt|\}} W n Y n X | sd}|r2|jjtjd |j| x,|D ]$}
|
jdkrg |
d d < |
}P qW |} nd }|jjtjd | rb| d dkrbd }n t| \}} |j s|jdkr| s| d dkr|j| |d k r|} || fS |jjtjd | s|jjtjd |j| |d kr|| fS n|d k rFx |D ]}
|
jdkrP qW |
jdk |j|
|
j|_| d dkrdtj dj| |jt
dd | dd } | r| d dkrt| \}} |j| |j|_| s| d dkrtj dj| |jt
dd | dd } |d k rJt } x>| rB| d tkr(t| \}} n t| \}} | j| qW | }n t| \}} |j| |d k rn|} || fS )aY attribute [section] ["*"] [CFWS] "=" value
The CFWS is implied by the RFC but not made explicit in the BNF. This
simplified form of the BNF from the RFC is made to conform with the RFC BNF
through some extra checks. We do it this way because it makes both error
recovery and working with the resulting parse tree easier.
r r z)Parameter contains name ({}) but no valuer- TzIncomplete parameterzextended-parameter-markerrj N=z Parameter not followed by '='zparameter-separatorr
F'z5Quoted string value for extended parameter is invalidzbare-quoted-stringzZParameter marked as extended but appears to have a quoted string value that is non-encodedzcApparent initial-extended-value but attribute was not marked as extended or was not initial sectionz(Missing required charset/lang delimiterszextended-attrtextr z=Expected RFC2231 char/lang encoding delimiter, but found {!r}zRFC2231-delimiterz;Expected RFC2231 char/lang encoding delimiter, but found {}) r r( rS r r r r# r/ r r r r r r r rV r r& r* r7 r1 r rP rQ r r r r ) r r r. r r ZappendtoZqstringZ inner_valueZ
semi_validr tr0 r r r
get_parameter s
r5 c C sh t }xZ| rbyt| \}} |j| W n tjk
r } zd}| d tkrZt| \}} | sl|j| |S | d dkr|dk r|j| |jjtjd n@t | \}} |r|g|dd< |j| |jjtjdj
| W Y dd}~X nX | r@| d dkr@|d
}d|_ t | \}} |j | |jjtjdj
| | r
|jt
dd | dd } q
W |S ) a! parameter *( ";" parameter )
That BNF is meant to indicate this routine should only be called after
finding and handling the leading ';'. There is no corresponding rule in
the formal RFC grammar, but it is more convenient for us for the set of
parameters to be treated as its own TokenList.
This is 'parse' routine because it consumes the reminaing value, but it
would never be called to parse a full header. Instead it is called to
parse everything after the non-parameter value of a specific MIME header.
Nr r z parameter entry with no contentzinvalid parameter {!r}rj zinvalid-parameterz)parameter with invalid trailing text {!r}zparameter-separatorrl )r r5 rS r r r r r r r r# r7 r, r )r Zmime_parametersr. r r r r r r parse_mime_parametersQ sD
r6 c C s xX|rX|d dkrX|d t kr@| jt|d d |dd }qt|\}}| j| qW |sbdS | jtdd | jt|dd dS )zBDo our best to find the parameters in an invalid MIME header
r r zmisplaced-specialrj Nzparameter-separator)r rS r r r6 )Z tokenlistr r. r r r _find_mime_parameters s r7 c C s t }d}| s$|jjtjd |S yt| \}} W n8 tjk
rl |jjtjdj| t || |S X |j| | s| d dkr|jjtjd | rt || |S |j
j j |_
|jtdd | dd } yt| \}} W n: tjk
r$ |jjtjd
j| t || |S X |j| |j
j j |_| sJ|S | d d kr|jjtjd j| |`
|`t || |S |jtd d
|jt| dd |S )z maintype "/" subtype *( ";" parameter )
The maintype and substype are tokens. Theoretically they could
be checked against the official IANA list + x-token, but we
don't do that.
Fz"Missing content type specificationz(Expected content maintype but found {!r}r r zInvalid content typezcontent-type-separatorrj Nz'Expected content subtype but found {!r}r z.z unknown-8bitTzmime-parameters)r/ r rl rl rl rl rl ) Zmax_line_lengthfloatutf8r r r r r7
SPECIALSNL
isdisjointNLSETr r r r& _fold_mime_parametersr) r; r1 rk linesepr= rS r8 _fold_as_ewr< r( insertr! )Z
parse_treer/ maxlenr r< last_ewr> Z
want_encodingZend_ew_not_allowedr r* tstrrP Z encoded_partnewlineZnewpartsr r r r0 "
s
r0 c C s |dk r<|r Fold TokenList 'part' into the 'lines' list as mime parameters.
Using the decoded list of parameters and values, format them according to
the RFC rules, including using RFC2231 encoding if the value cannot be
expressed in 'encoding' and/or the parameter+value is too long to fit
within 'maxlen'.
rj r strictFTz unknown-8bitr zutf-8r )Zsafer z
{}*={}''{}z{}={}r@ rh r z''r{ N Nz {}*{}*={}{}rl rl rl rl rl rl )r r| r r r r r r r rY r# r rk rS r )r* r< rH r r r rP Z
error_handlerZencoding_requiredZ
encoded_valuerJ r Z extra_chromeZ
chrome_lenZ
splitpointZmaxcharspartialr r r rD
s\
rD )__doc__rer stringr collectionsr operatorr Zemailr r r r r r r r r r r Z TSPECIALSr# Z ASPECIALSr' r+ rC rA r r r r? rD rF rH rI rK rM rN rR rW rX r[ r` rd rf rg ri rq rs rt ru rv rx ry rz r r r r r r r r r r r r r r r r r r r r r r r r r compiler# r! rw r r matchr findallr r! r% r) r r r r r r r r r r r r r r r r r r r r r r r r r
r
r r r r r r r r r r r r" r$ r& r( r* r, r/ r1 r5 r6 r7 r9 r: r; r= r0 rF rD r r r r D s C "
!($
V +
*8"
&'/'&). 9% >D 49 /j7PK ! _j j " __pycache__/message.cpython-36.pycnu [ 3
\ @ s d Z ddgZddlZddlZddlZddlmZmZ ddlm Z ddlm
Z
ddl m Z m
Z
dd lmZ dd
lmZ ejZd Zejd Zd
d ZdddZdd Zdd ZG dd dZG dd deZG dd deZ dS )z8Basic message object for the email package object model.Message EmailMessage N)BytesIOStringIO)utils)errors)Policycompat32)charset)decode_bz; z[ \(\)<>@,;:\\"/\[\]\?=]c C s4 t | jd\}}}|s$|j d fS |j |j fS )N;)str partitionstrip)paramasepb r %/usr/lib64/python3.6/email/message.py _splitparam s r Tc C s |dk rt |dkrt|trL| d7 } tj|d |d |d }d| |f S y|jd W n2 tk
r | d7 } tj|dd }d| |f S X |stj|rd
| tj |f S d| |f S n| S dS ) a~ Convenience function to format and return a key=value pair.
This will quote the value if needed or if quote is true. If value is a
three tuple (charset, language, value), it will be encoded according
to RFC2231 rules. If it contains non-ascii characters it will likewise
be encoded according to RFC2231 rules, using the utf-8 charset and
a null language.
Nr * z%s=%sasciizutf-8 z%s="%s")
len
isinstancetupler Zencode_rfc2231encodeUnicodeEncodeError tspecialssearchquote)r valuer# r r r _formatparam' s
r% c C s dt | } g }x| d d dkr| dd } | jd}x<|dkrt| jdd|| jdd| d rt| jd|d }q:W |dk rt| }| d | }d|kr|jd}|d | j j d ||d d j }|j|j | |d } qW |S )Nr r r "z\"r =)r
findcountr indexr lowerappend)sZplistendfir r r _parseparamI s
*
,r1 c C s4 t | tr&| d | d tj| d fS tj| S d S )Nr r r )r r r unquote)r$ r r r
_unquotevalue] s
r3 c @ s e Zd ZdZefddZdd Zddd d
Zd d Zded
dZ dd Z
dd Z dd Z dd Z
dfddZdgddZdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zdhd1d2Zd3d4 Z d5d6 Z did7d8Z d9d: Z d;d< Z d=d> Z!d?d@ Z"dAdB Z#dCdD Z$dEdF Z%dGdH Z&djdKdLZ'dkdMdNZ(dldQdRZ)dmdSdTZ*dndUdVZ+dodWdXZ,dpdYdZZ-d[d\ Z.dqd]d^Z/drd_d`Z0dadb Z1ddcl2m3Z3 dS )sr a Basic message object.
A message object is defined as something that has a bunch of RFC 2822
headers and a payload. It may optionally have an envelope header
(a.k.a. Unix-From or From_ header). If the message is a container (i.e. a
multipart or a message/rfc822), then the payload is a list of Message
objects, otherwise it is a string.
Message objects implement part of the `mapping' interface, which assumes
there is exactly one occurrence of the header per message. Some headers
do in fact appear multiple times (e.g. Received) and for those headers,
you must use the explicit API to set or get all the headers. Not all of
the mapping methods are implemented.
c C s: || _ g | _d | _d | _d | _d | _| _g | _d| _d S )Nz
text/plain) policy_headers _unixfrom_payload_charsetZpreambleZepiloguedefects
_default_type)selfr4 r r r __init__x s zMessage.__init__c C s | j S )z9Return the entire formatted message as a string.
) as_string)r; r r r __str__ s zMessage.__str__Fr Nc C sJ ddl m} |dkr| jn|}t }||d||d}|j| |d |j S )a Return the entire formatted message as a string.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. For backward compatibility reasons, if maxheaderlen is
not specified it defaults to 0, so you must override it explicitly
if you want a different maxheaderlen. 'policy' is passed to the
Generator instance used to serialize the mesasge; if it is not
specified the policy associated with the message instance is used.
If the message object contains binary data that is not encoded
according to RFC standards, the non-compliant data will be replaced by
unicode "unknown character" code points.
r ) GeneratorNF) mangle_from_ maxheaderlenr4 )unixfrom)email.generatorr? r4 r flattengetvalue)r; rB rA r4 r? fpgr r r r= s zMessage.as_stringc C s | j S )z?Return the entire formatted message as a bytes object.
)as_bytes)r; r r r __bytes__ s zMessage.__bytes__c C sH ddl m} |dkr| jn|}t }||d|d}|j| |d |j S )aJ Return the entire formatted message as a bytes object.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. 'policy' is passed to the BytesGenerator instance used to
serialize the message; if not specified the policy associated with
the message instance is used.
r )BytesGeneratorNF)r@ r4 )rB )rC rJ r4 r rD rE )r; rB r4 rJ rF rG r r r rH s zMessage.as_bytesc C s t | jtS )z6Return True if the message consists of multiple parts.)r r7 list)r; r r r is_multipart s zMessage.is_multipartc C s
|| _ d S )N)r6 )r; rB r r r set_unixfrom s zMessage.set_unixfromc C s | j S )N)r6 )r; r r r get_unixfrom s zMessage.get_unixfromc C sF | j dkr|g| _ n.y| j j| W n tk
r@ tdY nX dS )zAdd the given payload to the current payload.
The current payload will always be a list of objects after this method
is called. If you want to set the payload to a scalar object, use
set_payload() instead.
Nz=Attach is not valid on a message with a non-multipart payload)r7 r, AttributeError TypeError)r; payloadr r r attach s
zMessage.attachc C s | j r(|rdS |dkr | jS | j| S |dk rPt| jt rPtdt| j | j}t| jddj }t|trt j
|r|j dd}|sy|j | j
ddd}W n tk
r |j dd}Y nX n6|ry|j d}W n tk
r |j d }Y nX |s |S |d
kr tj|S |d krbtd j|j \}}x |D ]}| jj| | qFW |S |dkrt|} t }
ytj | |
dd |
j S tjk
r |S X t|tr|S |S )aZ Return a reference to the payload.
The payload will either be a list object or a string. If you mutate
the list object, you modify the message's payload in place. Optional
i returns that index into the payload.
Optional decode is a flag indicating whether the payload should be
decoded or not, according to the Content-Transfer-Encoding header
(default is False).
When True and the message is not a multipart, the payload will be
decoded if this header's value is `quoted-printable' or `base64'. If
some other encoding is used, or the header is missing, or if the
payload has bogus data (i.e. bogus base64 or uuencoded data), the
payload is returned as-is.
If the message is a multipart and the decode flag is True, then None
is returned.
NzExpected list, got %szcontent-transfer-encodingr r surrogateescaper
replacezraw-unicode-escapezquoted-printablebase64
x-uuencodeuuencodeuuex-uueT)quiet)rW rX rY rZ )rL r7 r rK rP typer
getr+ r Z_has_surrogatesr decode get_param LookupError UnicodeErrorquopriZ decodestringr join
splitlinesr4 Z
handle_defectr uurE Error) r; r0 r^ rQ cteZbpayloadr$ r9 ZdefectZin_fileZout_filer r r get_payload sV "
zMessage.get_payloadc C sp t |dr:|dkr || _dS t|ts.t|}|j|j}t |drT|jdd| _n|| _|dk rl| j| dS )zSet the payload to the given value.
Optional charset sets the message's default character set. See
set_charset() for details.
r Nr^ r rS )hasattrr7 r Charsetr output_charsetr^ set_charset)r; rQ r
r r r set_payload/ s
zMessage.set_payloadc C s |dkr | j d d| _dS t|ts.t|}|| _d| krH| jdd d| krf| jdd|j d n| jd|j ||j kr|j| j| _d| kr|j }y || W nj t
k
r | j}|ry|j d d
}W n t k
r |j |j
}Y nX |j|| _| jd| Y nX dS ) a Set the charset of the payload to a given character set.
charset can be a Charset instance, a string naming a character set, or
None. If it is a string it will be converted to a Charset instance.
If charset is None, the charset parameter will be removed from the
Content-Type field. Anything else will generate a TypeError.
The message will be assumed to be of type text/* encoded with
charset.input_charset. It will be converted to charset.output_charset
and encoded properly, if needed, when generating the plain text
representation of the message. MIME headers (MIME-Version,
Content-Type, Content-Transfer-Encoding) will be added as needed.
Nr
z MIME-Versionz1.0z Content-Typez
text/plain)r
zContent-Transfer-Encodingr rS ) del_paramr8 r rj
add_headerZget_output_charset set_paramZ body_encoder7 Zget_body_encodingrP r ra rk )r; r
rg rQ r r r rl C s8
zMessage.set_charsetc C s | j S )zKReturn the Charset instance associated with the message's payload.
)r8 )r; r r r get_charsetr s zMessage.get_charsetc C s
t | jS )z9Return the total number of headers, including duplicates.)r r5 )r; r r r __len__z s zMessage.__len__c C s
| j |S )a- Get a header value.
Return None if the header is missing instead of raising an exception.
Note that if the header appeared multiple times, exactly which
occurrence gets returned is undefined. Use get_all() to get all
the values matching a header field name.
)r] )r; namer r r __getitem__~ s zMessage.__getitem__c C sv | j j|}|r\|j }d}x>| jD ]4\}}|j |kr$|d7 }||kr$tdj||q$W | jj| j j|| dS )zSet the value of a header.
Note: this does not overwrite an existing header with the same field
name. Use __delitem__() first to delete any existing headers.
r r z/There may be at most {} {} headers in a messageN)r4 Zheader_max_countr+ r5
ValueErrorformatr, header_store_parse)r; rs valZ max_countZlnamefoundkvr r r __setitem__ s zMessage.__setitem__c C sD |j }g }x,| jD ]"\}}|j |kr|j||f qW || _dS )zwDelete all occurrences of a header, if present.
Does not raise an exception if the header is missing.
N)r+ r5 r, )r; rs
newheadersrz r{ r r r __delitem__ s zMessage.__delitem__c C s |j dd | jD kS )Nc S s g | ]\}}|j qS r )r+ ).0rz r{ r r r
s z(Message.__contains__..)r+ r5 )r; rs r r r __contains__ s zMessage.__contains__c c s x| j D ]\}}|V qW d S )N)r5 )r; Zfieldr$ r r r __iter__ s zMessage.__iter__c C s dd | j D S )a. Return a list of all the message's header field names.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c S s g | ] \}}|qS r r )r rz r{ r r r r s z Message.keys..)r5 )r; r r r keys s z Message.keysc s fdd j D S )a) Return a list of all the message's header values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c s g | ]\}} j j||qS r )r4 header_fetch_parse)r rz r{ )r; r r r s z"Message.values..)r5 )r; r )r; r values s
zMessage.valuesc s fdd j D S )a' Get all the message's header fields and values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c s" g | ]\}}| j j||fqS r )r4 r )r rz r{ )r; r r r s z!Message.items..)r5 )r; r )r; r items s
z
Message.itemsc C s: |j }x,| jD ]"\}}|j |kr| jj||S qW |S )z~Get a header value.
Like __getitem__() but return failobj instead of None when the field
is missing.
)r+ r5 r4 r )r; rs failobjrz r{ r r r r] s
z Message.getc C s | j j||f dS )zStore name and value in the model without modification.
This is an "internal" API, intended only for use by a parser.
N)r5 r, )r; rs r$ r r r set_raw s zMessage.set_rawc C s t | jj S )zReturn the (name, value) header pairs without modification.
This is an "internal" API, intended only for use by a generator.
)iterr5 copy)r; r r r raw_items s zMessage.raw_itemsc C sL g }|j }x2| jD ](\}}|j |kr|j| jj|| qW |sH|S |S )aQ Return a list of all the values for the named field.
These will be sorted in the order they appeared in the original
message, and may contain duplicates. Any fields deleted and
re-inserted are always appended to the header list.
If no such fields exist, failobj is returned (defaults to None).
)r+ r5 r, r4 r )r; rs r r rz r{ r r r get_all s zMessage.get_allc K st g }xH|j D ]<\}}|dkr2|j|jdd q|jt|jdd| qW |dk rb|jd| tj|| |< dS )u Extended header setting.
name is the header field to add. keyword arguments can be used to set
additional parameters for the header field, with underscores converted
to dashes. Normally the parameter will be added as key="value" unless
value is None, in which case only the key will be added. If a
parameter value contains non-ASCII characters it can be specified as a
three-tuple of (charset, language, value), in which case it will be
encoded according to RFC2231 rules. Otherwise it will be encoded using
the utf-8 charset and a language of ''.
Examples:
msg.add_header('content-disposition', 'attachment', filename='bud.gif')
msg.add_header('content-disposition', 'attachment',
filename=('utf-8', '', Fußballer.ppt'))
msg.add_header('content-disposition', 'attachment',
filename='Fußballer.ppt'))
N_-r )r r, rT r% insert SEMISPACErc )r; _name_valueZ_paramspartsrz r{ r r r ro s zMessage.add_headerc C s^ |j }xPttt| j| jD ].\}\}}|j |kr | jj||| j|< P q W t|dS )zReplace a header.
Replace the first matching header found in the message, retaining
header order and case. If no matching header was found, a KeyError is
raised.
N)r+ zipranger r5 r4 rw KeyError)r; r r r0 rz r{ r r r replace_header! s $ zMessage.replace_headerc C sH t }| jd|}||kr"| j S t|d j }|jddkrDdS |S )a0 Return the message's content type.
The returned string is coerced to lower case of the form
`maintype/subtype'. If there was no Content-Type header in the
message, the default type as given by get_default_type() will be
returned. Since according to RFC 2045, messages always have a default
type this will always return a value.
RFC 2045 defines a message's default type to be text/plain unless it
appears inside a multipart/digest container, in which case it would be
message/rfc822.
z content-typer /r z
text/plain)objectr] get_default_typer r+ r) )r; missingr$ ctyper r r get_content_type4 s
zMessage.get_content_typec C s | j }|jdd S )zReturn the message's main content type.
This is the `maintype' part of the string returned by
get_content_type().
r r )r split)r; r r r r get_content_maintypeL s z Message.get_content_maintypec C s | j }|jdd S )zReturns the message's sub-content type.
This is the `subtype' part of the string returned by
get_content_type().
r r )r r )r; r r r r get_content_subtypeU s zMessage.get_content_subtypec C s | j S )a Return the `default' content type.
Most messages have a default content type of text/plain, except for
messages that are subparts of multipart/digest containers. Such
subparts have a default content type of message/rfc822.
)r: )r; r r r r ^ s zMessage.get_default_typec C s
|| _ dS )zSet the `default' content type.
ctype should be either "text/plain" or "message/rfc822", although this
is not enforced. The default content type is not stored in the
Content-Type header.
N)r: )r; r r r r set_default_typeg s zMessage.set_default_typec C s t }| j||}||kr |S g }xdt|D ]X}y$|jdd\}}|j }|j }W n tk
rt |j }d}Y nX |j||f q,W tj|}|S )Nr' r r ) r r] r1 r r ru r, r Z
decode_params) r; r headerr r$ paramsprs rx r r r _get_params_preservep s
z Message._get_params_preserve content-typeTc C s8 t }| j||}||kr |S |r0dd |D S |S dS )am Return the message's Content-Type parameters, as a list.
The elements of the returned list are 2-tuples of key/value pairs, as
split on the `=' sign. The left hand side of the `=' is the key,
while the right hand side is the value. If there is no `=' sign in
the parameter the value is the empty string. The value is as
described in the get_param() method.
Optional failobj is the object to return if there is no Content-Type
header. Optional header is the header to search instead of
Content-Type. If unquote is True, the value is unquoted.
c S s g | ]\}}|t |fqS r )r3 )r rz r{ r r r r s z&Message.get_params..N)r r )r; r r r2 r r r r r
get_params s
zMessage.get_paramsc C sJ || kr |S x8| j ||D ](\}}|j |j kr|r>t|S |S qW |S )a Return the parameter value if found in the Content-Type header.
Optional failobj is the object to return if there is no Content-Type
header, or the Content-Type header has no such parameter. Optional
header is the header to search instead of Content-Type.
Parameter keys are always compared case insensitively. The return
value can either be a string, or a 3-tuple if the parameter was RFC
2231 encoded. When it's a 3-tuple, the elements of the value are of
the form (CHARSET, LANGUAGE, VALUE). Note that both CHARSET and
LANGUAGE can be None, in which case you should consider VALUE to be
encoded in the us-ascii charset. You can usually ignore LANGUAGE.
The parameter value (either the returned string, or the VALUE item in
the 3-tuple) is always unquoted, unless unquote is set to False.
If your application doesn't care whether the parameter was RFC 2231
encoded, it can turn the return value into a string as follows:
rawparam = msg.get_param('foo')
param = email.utils.collapse_rfc2231_value(rawparam)
)r r+ r3 )r; r r r r2 rz r{ r r r r_ s zMessage.get_param Content-Typer c C s t |t r|r|||f}|| kr4|j dkr4d}n
| j|}| j||dsv|s^t|||}qtj|t|||g}nfd}x`| j||dD ]N\} }
d} | j |j krt|||} n t| |
|} |s| }qtj|| g}qW || j|kr|r | j || n| |= || |< dS )a Set a parameter in the Content-Type header.
If the parameter already exists in the header, its value will be
replaced with the new value.
If header is Content-Type and has not yet been defined for this
message, it will be set to "text/plain" and the new parameter and
value will be appended as per RFC 2045.
An alternate header can be specified in the header argument, and all
parameters will be quoted as necessary unless requote is False.
If charset is specified, the parameter will be encoded according to RFC
2231. Optional language specifies the RFC 2231 language, defaulting
to the empty string. Both charset and language should be strings.
z content-typez
text/plain)r r )r r2 N)
r r r+ r] r_ r% r rc r r ) r; r r$ r requoter
ZlanguagerT r Z old_paramZ old_valueZ append_paramr r r rp s2
zMessage.set_paramc C s || kr dS d}xR| j ||dD ]@\}}|j |j kr |sJt|||}q tj|t|||g}q W || j|kr| |= || |< dS )a> Remove the given parameter completely from the Content-Type header.
The header will be re-written in place without the parameter or its
value. All values will be quoted as necessary unless requote is
False. Optional header specifies an alternative to the Content-Type
header.
Nr )r r2 )r r+ r% r rc r] )r; r r r Z new_ctyper r{ r r r rn s zMessage.del_paramc C s |j ddkst|j dkr,| d= d| d< || kr@|| |< dS | j||d}| |= || |< x(|dd D ]\}}| j|||| qjW dS ) aK Set the main type and subtype for the Content-Type header.
type must be a string in the form "maintype/subtype", otherwise a
ValueError is raised.
This method replaces the Content-Type header, keeping all the
parameters in place. If requote is False, this leaves the existing
header's quoting as is. Otherwise, the parameters will be quoted (the
default).
An alternative header can be specified in the header argument. When
the Content-Type header is set, we'll always also add a MIME-Version
header.
r r z content-typez mime-versionz1.0z MIME-VersionN)r r2 )r) ru r+ r rp )r; r\ r r r r r{ r r r set_type s zMessage.set_typec C sD t }| jd|d}||kr*| jd|d}||kr6|S tj|j S )a@ Return the filename associated with the payload if present.
The filename is extracted from the Content-Disposition header's
`filename' parameter, and it is unquoted. If that header is missing
the `filename' parameter, this method falls back to looking for the
`name' parameter.
filenamezcontent-dispositionrs z content-type)r r_ r collapse_rfc2231_valuer )r; r r r r r r get_filename& s zMessage.get_filenamec C s, t }| jd|}||kr |S tj|j S )zReturn the boundary associated with the payload if present.
The boundary is extracted from the Content-Type header's `boundary'
parameter, and it is unquoted.
boundary)r r_ r r rstrip)r; r r r r r r get_boundary6 s
zMessage.get_boundaryc C s t }| j|d}||kr$tjdg }d}xB|D ]:\}}|j dkr^|jdd| f d}q2|j||f q2W |s|jdd| f g }x| jD ]\} }
| j dkrg } x6|D ].\} }
|
dkr| j| q| jd| |
f qW tj| }
|j| j j
| |
q|j| |
f qW || _d S )
a Set the boundary parameter in Content-Type to 'boundary'.
This is subtly different than deleting the Content-Type header and
adding a new one with a new boundary parameter via add_header(). The
main difference is that using the set_boundary() method preserves the
order of the Content-Type header in the original message.
HeaderParseError is raised if the message has no Content-Type header.
z content-typez No Content-Type header foundFr z"%s"Tr z%s=%sN) r r r ZHeaderParseErrorr+ r, r5 r rc r4 rw )r; r r r Z newparamsZfoundpZpkZpvr} hr{ r rz rx r r r set_boundaryC s2
zMessage.set_boundaryc C s t }| jd|}||kr |S t|trr|d p2d}y |d jd}t||}W n ttfk
rp |d }Y nX y|jd W n tk
r |S X |j S )zReturn the charset parameter of the Content-Type header.
The returned string is always coerced to lower case. If there is no
Content-Type header, or if that header has no charset parameter,
failobj is returned.
r
r zus-asciir zraw-unicode-escape) r r_ r r r r
r` ra r+ )r; r r r
ZpcharsetrH r r r get_content_charsetq s
zMessage.get_content_charsetc s fdd| j D S )a Return a list containing the charset(s) used in this message.
The returned list of items describes the Content-Type headers'
charset parameter for this message and all the subparts in its
payload.
Each item will either be a string (the value of the charset parameter
in the Content-Type header of that part) or the value of the
'failobj' parameter (defaults to None), if the part does not have a
main MIME type of "text", or the charset is not defined.
The list will contain one string for each part of the message, plus
one for the container message (i.e. self), so that a non-multipart
message will still return a list of length 1.
c s g | ]}|j qS r )r )r part)r r r r s z(Message.get_charsets..)walk)r; r r )r r get_charsets s zMessage.get_charsetsc C s* | j d}|dkrdS t|d j }|S )zReturn the message's content-disposition if it exists, or None.
The return values can be either 'inline', 'attachment' or None
according to the rfc2183.
zcontent-dispositionNr )r] r r+ )r; r$ c_dr r r get_content_disposition s
z Message.get_content_disposition)r )Fr N)FN)NF)N)N)N)Nr T)Nr T)r TNr F)r T)r T)N)N)N)N)4__name__
__module__ __qualname____doc__r r< r> r= rI rH rL rM rN rR rh rm rl rq rr rt r| r~ r r r r r r] r r r ro r r r r r r r r r_ rp rn r r r r r r r Zemail.iteratorsr r r r r r i sb
Z
/
!
2
.
c s e Zd Zd3ddZd4 fdd Zdd Zd d
Zd d Zd6ddZd7d8d9d:hZ dd Z
dd Z ddddZ ddd d Z
d d Zd;d d!ZdMIMEPartNc C s( |d krddl m} |}tj| | d S )Nr )default)Z email.policyr r r< )r; r4 r r r r r< s zMIMEPart.__init__Fc s0 |dkr| j n|}|dkr |j}t j||dS )a Return the entire formatted message as a string.
Optional 'unixfrom', when true, means include the Unix From_ envelope
header. maxheaderlen is retained for backward compatibility with the
base Message class, but defaults to None, meaning that the policy value
for max_line_length controls the header maximum length. 'policy' is
passed to the Generator instance used to serialize the mesasge; if it
is not specified the policy associated with the message instance is
used.
N)rA r4 )r4 Zmax_line_lengthsuperr= )r; rB rA r4 ) __class__r r r= s zMIMEPart.as_stringc C s | j | jjdddS )NT)utf8)r4 )r= r4 Zclone)r; r r r r> s zMIMEPart.__str__c C s | j d}|d krdS |jdkS )Nzcontent-dispositionF
attachment)r] Zcontent_disposition)r; r r r r
is_attachment s
zMIMEPart.is_attachmentc c s |j r d S |j jd\}}|dkrB||kr>|j||fV d S |dkrNd S |dkr~x"|j D ]}| j||E d H q`W d S d|kr|jd|fV d }|jd}|rx"|j D ]}|d |kr|}P qW |d kr|j }|r|d nd }|d k r| j||E d H d S )Nr text multipartrelatedstartz
content-idr )r r r r*
iter_parts
_find_bodyr_ rh ) r; r preferencelistmaintypesubtypeZsubpart candidater Zsubpartsr r r r s6
zMIMEPart._find_bodyr htmlplainc C sD t |}d}x2| j| |D ]"\}}||k r|}|}|dkrP qW |S )a Return best candidate mime part for display as 'body' of message.
Do a depth first search, starting with self, looking for the first part
matching each of the items in preferencelist, and return the part
corresponding to the first item that has a match, or None if no items
have a match. If 'related' is not included in preferencelist, consider
the root part of any multipart/related encountered as a candidate
match. Ignore parts with 'Content-Disposition: attachment'.
Nr )r r )r; r Z best_prioZbodyZprior r r r get_body s
zMIMEPart.get_bodyr r alternativec c s | j jd\}}|dks"|dkr&dS | j j }|dkr|dkr| jd}|rd}g }x*|D ]"}|jd|krvd }q^|j| q^W |r|E dH dS |jd
|E dH dS g }xP|D ]H}|j jd\}}||f| jkr|j r||kr|j| q|V qW dS ) a Return an iterator over the non-main parts of a multipart.
Skip the first of each occurrence of text/plain, text/html,
multipart/related, or multipart/alternative in the multipart (unless
they have a 'Content-Disposition: attachment' header) and include all
remaining subparts in the returned iterator. When applied to a
multipart/related, return all parts except the root part. Return an
empty iterator when applied to a multipart/alternative or a
non-multipart.
r r r Nr r Fz
content-idTr )
r r rh r r_ r] r, pop _body_typesr ) r; r r r r ry Z attachmentsr seenr r r iter_attachments s6
zMIMEPart.iter_attachmentsc c s | j dkr| j E dH dS )z~Return an iterator over all immediate subparts of a multipart.
Return an empty iterator for a non-multipart.
r N)r rh )r; r r r r 4 s zMIMEPart.iter_parts)content_managerc O s" |d kr| j j}|j| f||S )N)r4 r get_content)r; r argskwr r r r < s zMIMEPart.get_contentc O s& |d kr| j j}|j| f|| d S )N)r4 r set_content)r; r r r r r r r A s zMIMEPart.set_contentc
C s | j dkr6| j }||f }||kr6tdj||g }g }x>| jD ]4\}}|j jdrl|j||f qF|j||f qFW |rt| | j d} || _| j
| _
| g| _
ng | _
|| _d| | d< |d k r| j d| d S )Nr zCannot convert {} to {}zcontent-)r4 z
multipart/z Content-Typer ) r r ru rv r5 r+
startswithr, r\ r4 r7 rp )
r; r Zdisallowed_subtypesr Zexisting_subtypeZ keep_headersZ part_headersrs r$ r r r r _make_multipartF s,
zMIMEPart._make_multipartc C s | j dd| d S )Nr r mixed)r r )r )r; r r r r make_relateda s zMIMEPart.make_relatedc C s | j dd| d S )Nr r )r )r )r; r r r r make_alternatived s zMIMEPart.make_alternativec C s | j df | d S )Nr )r )r; r r r r
make_mixedg s zMIMEPart.make_mixed)_dispc O sf | j dks| j |kr(t| d| t| | jd}|j|| |rXd|krX||d< | j| d S )Nr Zmake_)r4 zcontent-dispositionzContent-Disposition)r r getattrr\ r4 r rR )r; Z_subtyper r r r r r r _add_multipartj s zMIMEPart._add_multipartc O s | j d|ddi| d S )Nr r Zinline)r )r )r; r r r r r add_relatedt s zMIMEPart.add_relatedc O s | j d|| d S )Nr )r )r )r; r r r r r add_alternativew s zMIMEPart.add_alternativec O s | j d|ddi| d S )Nr r r )r )r )r; r r r r r add_attachmentz s zMIMEPart.add_attachmentc C s g | _ d | _d S )N)r5 r7 )r; r r r clear} s zMIMEPart.clearc C s dd | j D | _ d | _d S )Nc S s& g | ] \}}|j jd s||fqS )zcontent-)r+ r )r nr{ r r r r s z*MIMEPart.clear_content..)r5 r7 )r; r r r
clear_content s zMIMEPart.clear_content)N)FNNr r r )r )r r )r r )r r )r r )N)N)N)r r r r< r= r> r r r r r r r r r r r r r r r r r r
__classcell__r r )r r r s0
.
r c s e Zd Z fddZ ZS )r c s" t j|| d| kr d| d< d S )Nz MIME-Versionz1.0)r r )r; r r )r r r r s zEmailMessage.set_content)r r r r r r r )r r r s )NT) r __all__rere rb ior r Zemailr r Zemail._policybaser r r
r8 Zemail._encoded_wordsr rj r compiler! r r% r1 r3 r r r r r r r s6
" N WPK ! Z) ) % __pycache__/feedparser.cpython-36.pycnu [ 3
\X @ s d Z ddgZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ej d Z ej d
Z
ej d Zej d
Zej d Zd
ZdZe ZG dd deZG dd dZG dd deZdS )a FeedParser - An email feed parser.
The feed parser implements an interface for incrementally parsing an email
message, line by line. This has advantages for certain applications, such as
those reading email messages off a socket.
FeedParser.feed() is the primary interface for pushing new data into the
parser. It returns when there's nothing more it can do with the available
data. When you have no more data to push into the parser, call .close().
This completes the parsing and returns the root message object.
The other advantage of this parser is that it will never raise a parsing
exception. Instead, when it finds something unexpected, it adds a 'defect' to
the current message. Defects are just instances that live on the message
object's .defects attribute.
FeedParserBytesFeedParser N)errors)compat32)deque)StringIOz
\r\n|\r|\nz (\r\n|\r|\n)z(\r\n|\r|\n)\Zz%^(From |[\041-\071\073-\176]*:|[\t ])
c @ s` e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dS )BufferedSubFileak A file-ish object that can have new data loaded into it.
You can also push and pop line-matching predicates onto a stack. When the
current predicate matches the current line, a false EOF response
(i.e. empty string) is returned instead. This lets the parser adhere to a
simple abstraction -- it parses until EOF closes the current message.
c C s$ t dd| _t | _g | _d| _d S )Nr )newlineF)r _partialr _lines _eofstack_closed)self r (/usr/lib64/python3.6/email/feedparser.py__init__5 s zBufferedSubFile.__init__c C s | j j| d S )N)r append)r Zpredr r r push_eof_matcher@ s z BufferedSubFile.push_eof_matcherc C s
| j j S )N)r pop)r r r r pop_eof_matcherC s z BufferedSubFile.pop_eof_matcherc C s< | j jd | j| j j | j jd | j j d| _d S )Nr T)r seek pushlines readlinestruncater )r r r r closeF s
zBufferedSubFile.closec C sN | j s| jrdS tS | j j }x*t| jD ] }||r*| j j| dS q*W |S )Nr )r
r NeedMoreDatapopleftreversedr
appendleft)r lineZateofr r r readlineN s
zBufferedSubFile.readlinec C s |t k s t| jj| d S )N)r AssertionErrorr
r )r r! r r r
unreadline` s zBufferedSubFile.unreadlinec C sx | j j| d|kr d|kr dS | j jd | j j }| j jd | j j |d jdsj| j j|j | j| dS )z$Push some new data into this object.r
Nr )r writer r r endswithr r )r datapartsr r r pushe s
zBufferedSubFile.pushc C s | j j| d S )N)r
extend)r linesr r r r z s zBufferedSubFile.pushlinesc C s | S )Nr )r r r r __iter__} s zBufferedSubFile.__iter__c C s | j }|dkrt|S )Nr )r"
StopIteration)r r! r r r __next__ s zBufferedSubFile.__next__N)__name__
__module__ __qualname____doc__r r r r r" r$ r, r r/ r1 r r r r r
- s r
c @ s` e Zd ZdZdedddZdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dS )r z A feed-style parser of email.N)policyc C s || _ d| _|dkr<|jdkr2ddlm} || _qn|j| _n2|| _y|| j d W n tk
rl d| _Y nX t | _g | _ | j
j | _ d| _
d| _d| _dS )a _factory is called with no arguments to create a new message obj
The policy keyword specifies a policy object that controls a number of
aspects of the parser's operation. The default policy maintains
backward compatibility.
FNr )Message)r6 T)r6 _old_style_factoryZmessage_factoryZ
email.messager7 _factory TypeErrorr
_input _msgstack _parsegenr1 _parse_cur_last _headersonly)r r9 r6 r7 r r r r s$
zFeedParser.__init__c C s
d| _ d S )NT)rA )r r r r _set_headersonly s zFeedParser._set_headersonlyc C s | j j| | j dS )z Push more data into the parser.N)r; r, _call_parse)r r* r r r feed s zFeedParser.feedc C s& y | j W n tk
r Y nX d S )N)r> r0 )r r r r rC s zFeedParser._call_parsec C sV | j j | j | j }| j s&t|j dkrR|j rRtj }| j
j || |S )zz4)(?P--)?(?P[ \t]*)(?P\r\n|\r|\n)?$TFendlinesepr& r )rQ rP rR r' r' )/rM r; r headerREmatchNLCREr Z MissingHeaderBodySeparatorDefectr6 rH r? r$ r _parse_headersrA r" Z set_payload EMPTYSTRINGjoinrK r r= rF r rG Z get_boundaryZNoBoundaryInMultipartDefectgetlowerZ-InvalidMultipartContentTransferEncodingDefectrecompileescapegroup NLCRE_eolsearchlenpreambler@ epilogueZ_payload
isinstancestrr# ZStartBoundaryNotFoundDefectZCloseBoundaryNotFoundDefect NLCRE_bol)r Zheadersr! rJ r. rN rL boundaryZ separatorZ
boundaryreZcapturing_preamblerd rT Zclose_boundary_seenmoZlastlineZeolmore rS Zpayload firstlineZbolmor r r r= sh
zFeedParser._parsegenc C sp d}g }xFt |D ]8\}}|d dkrV|sJtj|}| jj| j| q|j| q|rx| jj| jj| dg }}|j d r|dkrt
j |}|r|d t |j
d }| jj| qn:|t |d kr| jj| d S tj|}| jjj| q|jd}|dkr*tjd}| jjj| q|dks s(
[ PK ! p`a{" {" + __pycache__/feedparser.cpython-36.opt-2.pycnu [ 3
\X @ s d dgZ ddlZddlmZ ddlmZ ddlmZ ddlm Z ej
dZ ej
d Z ej
d
Z
ej
d Zej
d Zd Zd
Ze ZG dd deZG dd d ZG dd deZdS )
FeedParserBytesFeedParser N)errors)compat32)deque)StringIOz
\r\n|\r|\nz (\r\n|\r|\n)z(\r\n|\r|\n)\Zz%^(From |[\041-\071\073-\176]*:|[\t ])
c @ s\ e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dd Z dS )BufferedSubFilec C s$ t dd| _t | _g | _d| _d S )Nr )newlineF)r _partialr _lines _eofstack_closed)self r (/usr/lib64/python3.6/email/feedparser.py__init__5 s zBufferedSubFile.__init__c C s | j j| d S )N)r append)r Zpredr r r push_eof_matcher@ s z BufferedSubFile.push_eof_matcherc C s
| j j S )N)r pop)r r r r pop_eof_matcherC s z BufferedSubFile.pop_eof_matcherc C s< | j jd | j| j j | j jd | j j d| _d S )Nr T)r seek pushlines readlinestruncater )r r r r closeF s
zBufferedSubFile.closec C sN | j s| jrdS tS | j j }x*t| jD ] }||r*| j j| dS q*W |S )Nr )r
r NeedMoreDatapopleftreversedr
appendleft)r lineZateofr r r readlineN s
zBufferedSubFile.readlinec C s | j j| d S )N)r
r )r r! r r r
unreadline` s zBufferedSubFile.unreadlinec C sx | j j| d|kr d|kr d S | j jd | j j }| j jd | j j |d jdsj| j j|j | j| d S )Nr
r )r writer r r endswithr r )r datapartsr r r pushe s
zBufferedSubFile.pushc C s | j j| d S )N)r
extend)r linesr r r r z s zBufferedSubFile.pushlinesc C s | S )Nr )r r r r __iter__} s zBufferedSubFile.__iter__c C s | j }|dkrt|S )Nr )r"
StopIteration)r r! r r r __next__ s zBufferedSubFile.__next__N)
__name__
__module__ __qualname__r r r r r" r# r+ r r. r0 r r r r r
- s r
c @ s\ e Zd ZdedddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dd Z dS )r N)policyc C s || _ d| _|d kr<|jd kr2ddlm} || _qn|j| _n2|| _y|| j d W n tk
rl d| _Y nX t | _g | _ | j
j | _ d | _
d | _d| _d S )NFr )Message)r4 T)r4 _old_style_factoryZmessage_factoryZ
email.messager5 _factory TypeErrorr
_input _msgstack _parsegenr0 _parse_cur_last _headersonly)r r7 r4 r5 r r r r s$
zFeedParser.__init__c C s
d| _ d S )NT)r? )r r r r _set_headersonly s zFeedParser._set_headersonlyc C s | j j| | j d S )N)r9 r+ _call_parse)r r) r r r feed s zFeedParser.feedc C s& y | j W n tk
r Y nX d S )N)r< r/ )r r r r rA s zFeedParser._call_parsec C sJ | j j | j | j }|j dkrF|j rFtj }| jj || |S )N multipart)
r9 r rA _pop_messageget_content_maintypeZ is_multipartr Z!MultipartInvariantViolationDefectr4
handle_defect)r rootdefectr r r r s
zFeedParser.closec C sn | j r| j }n| j| jd}| jr<| jj dkr<|jd | jrR| jd j| | jj| || _|| _ d S )N)r4 zmultipart/digestzmessage/rfc822r% r& )
r6 r7 r4 r= get_content_typeZset_default_typer: Zattachr r> )r msgr r r _new_message s
zFeedParser._new_messagec C s( | j j }| j r | j d | _nd | _|S )Nr% r& )r: r r= )r retvalr r r rD s
zFeedParser._pop_messagec c s6 | j g }xb| jD ]X}|tkr(tV qtj|sbtj|s`tj }| jj | j
| | jj | P |j | qW | j
| | jrg }x2| jj }|tkrtV q|dkrP |j | qW | j
jtj| d S | j
j dkrx| jjtj x$| j D ]}|tkrtV qP qW | j }| jj x&| jj }|tkrFtV q(P q(W x&| jj }|tkrntV qPP qPW |dkrP | jj | qW d S | j
j dkrx(| j D ] }|tkrtV qP qW | j d S | j
j dkr| j
j }|d krbtj }| jj | j
| g }x.| jD ]$}|tkrtj+ }| jj | j
| | j
jtj| g }x$| jD ]}|tkrtV qqW tj|| j
_'d S |
s`tj, }| jj | j
| d S | rndg}ng }x.| jD ]$}|tkrtV qz|j | qzW |r|d }t-j|}|r|t$|j!dd |d< tj|| j
_'d S g }x.| jD ]$}|tkrtV q|j | qW | j
jtj| d S )Nr zmessage/delivery-statusmessagerC zcontent-transfer-encoding8bit7bitbinaryz--z(?Pz4)(?P--)?(?P[ \t]*)(?P\r\n|\r|\n)?$TFendlinesepr% r )rO rN rP r& r& ).rK r9 r headerREmatchNLCREr Z MissingHeaderBodySeparatorDefectr4 rF r= r# r _parse_headersr? r" Z set_payload EMPTYSTRINGjoinrI r r; rD r rE Z get_boundaryZNoBoundaryInMultipartDefectgetlowerZ-InvalidMultipartContentTransferEncodingDefectrecompileescapegroup NLCRE_eolsearchlenpreambler> epilogueZ_payload
isinstancestrZStartBoundaryNotFoundDefectZCloseBoundaryNotFoundDefect NLCRE_bol)r Zheadersr! rH r- rL rJ boundaryZ separatorZ
boundaryreZcapturing_preamblerb rR Zclose_boundary_seenmoZlastlineZeolmorc rQ Zpayload firstlineZbolmor r r r; sf
zFeedParser._parsegenc C s^ d}g }x4t |D ]&\}}|d dkrV|sJtj|}| jj| j| q|j| q|rx| jj| jj| dg }}|j d r|dkrt
j |}|r|d t |j
d }| jj| qn:|t |d kr| jj| d S tj|}| jjj| q|jd}|dkr*tjd}| jjj| q|d | }|g}qW |rZ| jj| jj| d S )Nr r z zFrom r% :zMissing header name.) enumerater Z#FirstHeaderLineIsContinuationDefectr4 rF r= r Zset_rawZheader_source_parse
startswithr_ r` ra r^ Z set_unixfromr9 r# Z MisplacedEnvelopeHeaderDefectZdefectsfindZInvalidHeaderDefect) r r- Z
lastheaderZ lastvaluelinenor! rH rh ir r r rV sF
zFeedParser._parse_headers)N)
r1 r2 r3 r r r@ rB rA r rK rD r; rV r r r r r s
~c s e Zd Z fddZ ZS )r c s t j|jdd d S )Nasciisurrogateescape)superrB decode)r r) ) __class__r r rB s zBytesFeedParser.feed)r1 r2 r3 rB
__classcell__r r )rt r r s )__all__r[ Zemailr Zemail._policybaser collectionsr ior r\ rU rf r_ Z NLCRE_crackrS rW NLobjectr r
r r r r r r s&
[ PK ! 5T, , " __pycache__/charset.cpython-36.pycnu [ 3
\B @ sr d dddgZ ddlmZ ddlZddlZddlmZ ddlmZ d Z d
Z
d Z d Z d
Z
dZdZe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfd*e
e
dfe
e
dfe
ddfe
ddfe
ddfe
e
dfe e
dfdZddddddddddddddddddd d d d d d
d Zd!d"dd#Zd+d$dZd%d Zd&d Zd'd( ZG d)d d ZdS ),Charset add_alias add_charset add_codec )partialN)errors)encode_7or8bit zus-asciiz unknown-8bit z iso-2022-jpzutf-8)z
iso-8859-1z
iso-8859-2z
iso-8859-3z
iso-8859-4z
iso-8859-9z iso-8859-10z iso-8859-13z iso-8859-14z iso-8859-15z iso-8859-16z windows-1252Zvisciizus-asciibig5gb2312zeuc-jp shift_jisz iso-2022-jpzkoi8-rzutf-8z
iso-8859-1z
iso-8859-2z
iso-8859-3z
iso-8859-4z
iso-8859-9z iso-8859-10z iso-8859-13z iso-8859-14z iso-8859-15z iso-8859-16zks_c_5601-1987zeuc-jpzeuc-kr)latin_1zlatin-1Zlatin_2zlatin-2Zlatin_3zlatin-3Zlatin_4zlatin-4Zlatin_5zlatin-5Zlatin_6zlatin-6Zlatin_7zlatin-7Zlatin_8zlatin-8Zlatin_9zlatin-9Zlatin_10zlatin-10cp949euc_jpeuc_krascii eucgb2312_cnbig5_tw)r r zus-asciic C s" |t krtd|||ft| < dS )a> Add character set properties to the global registry.
charset is the input character set, and must be the canonical name of a
character set.
Optional header_enc and body_enc is either Charset.QP for
quoted-printable, Charset.BASE64 for base64 encoding, Charset.SHORTEST for
the shortest of qp or base64 encoding, or None for no encoding. SHORTEST
is only valid for header_enc. It describes how message headers and
message bodies in the input charset are to be encoded. Default is no
encoding.
Optional output_charset is the character set that the output should be
in. Conversions will proceed from input charset, to Unicode, to the
output charset when the method Charset.convert() is called. The default
is to output in the same character set as the input.
Both input_charset and output_charset must have Unicode codec entries in
the module's charset-to-codec mapping; use add_codec(charset, codecname)
to add codecs the module does not know about. See the codecs module's
documentation for more information.
z!SHORTEST not allowed for body_encN)SHORTEST
ValueErrorCHARSETS)charsetZ
header_encZbody_encoutput_charset r %/usr/lib64/python3.6/email/charset.pyr m s c C s |t | < dS )zAdd a character set alias.
alias is the alias name, e.g. latin-1
canonical is the character set's canonical name, e.g. iso-8859-1
N)ALIASES)aliasZ canonicalr r r r s c C s |t | < dS )a$ Add a codec that map characters in the given charset to/from Unicode.
charset is the canonical name of a character set. codecname is the name
of a Python codec, as appropriate for the second argument to the unicode()
built-in, or to the encode() method of a Unicode string.
N) CODEC_MAP)r Z codecnamer r r r s c C s" |t kr| jddS | j|S d S )Nr surrogateescape) UNKNOWN8BITencode)stringcodecr r r _encode s r' c @ s` e Zd ZdZefddZdd ZeZdd Zdd Z d
d Z
d d
Z dd Z dd Z
dd ZdS )r a@ Map character sets to their email properties.
This class provides information about the requirements imposed on email
for a specific character set. It also provides convenience routines for
converting between character sets, given the availability of the
applicable codecs. Given a character set, it will do its best to provide
information on how to use that character set in an email in an
RFC-compliant way.
Certain character sets must be encoded with quoted-printable or base64
when used in email headers or bodies. Certain character sets must be
converted outright, and are not allowed in email. Instances of this
module expose the following information about a character set:
input_charset: The initial character set specified. Common aliases
are converted to their `official' email names (e.g. latin_1
is converted to iso-8859-1). Defaults to 7-bit us-ascii.
header_encoding: If the character set must be encoded before it can be
used in an email header, this attribute will be set to
Charset.QP (for quoted-printable), Charset.BASE64 (for
base64 encoding), or Charset.SHORTEST for the shortest of
QP or BASE64 encoding. Otherwise, it will be None.
body_encoding: Same as header_encoding, but describes the encoding for the
mail message's body, which indeed may be different than the
header encoding. Charset.SHORTEST is not allowed for
body_encoding.
output_charset: Some character sets must be converted before they can be
used in email headers or bodies. If the input_charset is
one of them, this attribute will contain the name of the
charset output will be converted to. Otherwise, it will
be None.
input_codec: The name of the Python codec used to convert the
input_charset to Unicode. If no conversion codec is
necessary, this attribute will be None.
output_codec: The name of the Python codec used to convert Unicode
to the output_charset. If no conversion codec is necessary,
this attribute will have the same value as the input_codec.
c
C s y$t |tr|jd n
t|d}W n tk
rB tj|Y nX |j }tj||| _ t
j| j t t d f\}}}|s~| j }|| _
|| _tj||| _tj| j | j | _tj| j| j| _d S )Nr )
isinstancestrr$ UnicodeErrorr Z CharsetErrorlowerr get
input_charsetr r BASE64header_encoding
body_encodingr r! Z input_codec output_codec)selfr- ZhencZbencZconvr r r __init__ s&
zCharset.__init__c C s
| j j S )N)r- r+ )r2 r r r __str__ s zCharset.__str__c C s t | t |j kS )N)r) r+ )r2 otherr r r __eq__ s zCharset.__eq__c C s2 | j tkst| j tkr dS | j tkr*dS tS dS )aP Return the content-transfer-encoding used for body encoding.
This is either the string `quoted-printable' or `base64' depending on
the encoding used, or it is a function in which case you should call
the function with a single argument, the Message object being
encoded. The function should then set the Content-Transfer-Encoding
header itself to whatever is appropriate.
Returns "quoted-printable" if self.body_encoding is QP.
Returns "base64" if self.body_encoding is BASE64.
Returns conversion function otherwise.
zquoted-printablebase64N)r0 r AssertionErrorQPr. r )r2 r r r get_body_encoding s
zCharset.get_body_encodingc C s | j p
| jS )zReturn the output character set.
This is self.output_charset if that is not None, otherwise it is
self.input_charset.
)r r- )r2 r r r get_output_charset s zCharset.get_output_charsetc C s6 | j pd}t||}| j|}|dkr*|S |j||S )a Header-encode a string by converting it first to bytes.
The type of encoding (base64 or quoted-printable) will be based on
this charset's `header_encoding`.
:param string: A unicode string for the header. It must be possible
to encode this string to bytes using the character set's
output codec.
:return: The encoded string, with RFC 2047 chrome.
zus-asciiN)r1 r' _get_encoder
header_encode)r2 r% r& header_bytesencoder_moduler r r r= s
zCharset.header_encodec C s | j pd}t||}| j|}t|j|d}| j }t|t }g } g }
t|| } x|D ]} |
j | t
j |
}
|j t|
|}|| krZ|
j
| r|
r| j d n.| rdnd}t
j |
}t||}| j || | g}
t|| } qZW t
j |
}t||}| j || | S )af Header-encode a string by converting it first to bytes.
This is similar to `header_encode()` except that the string is fit
into maximum line lengths as given by the argument.
:param string: A unicode string for the header. It must be possible
to encode this string to bytes using the character set's
output codec.
:param maxlengths: Maximum line length iterator. Each element
returned from this iterator will provide the next maximum line
length. This parameter is used as an argument to built-in next()
and should never be exhausted. The maximum line lengths should
not count the RFC 2047 chrome. These line lengths are only a
hint; the splitter does the best it can.
:return: Lines of encoded strings, each with RFC 2047 chrome.
zus-ascii)r N r
)r1 r' r< r r= r; lenRFC2047_CHROME_LENnextappend EMPTYSTRINGjoin
header_lengthpop)r2 r% Z
maxlengthsr& r> r? encoderr ZextralinesZ current_linemaxlen characterZ this_lineZlengthZ separatorZ joined_liner r r header_encode_lines, s6
zCharset.header_encode_linesc C s` | j tkrtjS | j tkr tjS | j tkrXtjj|}tjj|}||k rPtjS tjS nd S d S )N)r/ r. email
base64mimer9
quoprimimer rG )r2 r> Zlen64Zlenqpr r r r< j s
zCharset._get_encoderc C s |s|S | j tkr4t|tr(|j| j}tjj|S | j t krjt|trT|j| j}|j
d}tj j|S t|tr|j| jj
d}|S dS )av Body-encode a string by converting it first to bytes.
The type of encoding (base64 or quoted-printable) will be based on
self.body_encoding. If body_encoding is None, we assume the
output charset is a 7bit encoding, so re-encoding the decoded
string using the ascii codec produces the correct string version
of the content.
latin1r N) r0 r. r( r) r$ r rN rO body_encoder9 decoderP )r2 r% r r r rR y s
zCharset.body_encodeN)__name__
__module__ __qualname____doc__DEFAULT_CHARSETr3 r4 __repr__r6 r: r; r= rM r< rR r r r r r s + !>)NNN)NNN)__all__ functoolsr Zemail.base64mimerN Zemail.quoprimimer Zemail.encodersr r9 r. r rB rX r# rE r r r! r r r r' r r r r r s
PK ! pJjm m + __pycache__/quoprimime.cpython-36.opt-2.pycnu [ 3
\&
@ s` d ddddddddd g
Z d
d lZd
d lmZmZmZ d
ZdZdZdd e dD Z
e
d d Z e
d d Z x,dej
d ej
d D ]Zeee e< qW de ed< xdD ]Zeee e< qW dd Zdd Zd d Zd d Zd+d d Zd d Zd!d Zd,d#dZe d d Zxd$D ]Zeeee< qW d%efd&dZefd'dZeZ eZ d(d) Z d*d Z d S )- body_decode body_encode body_lengthdecode decodestring
header_decode
header_encode
header_lengthquoteunquote N)
ascii_lettersdigits hexdigitsz
c C s g | ] }d | qS )z=%02X ).0cr r (/usr/lib64/python3.6/email/quoprimime.py
7 s r s -!*+/ascii_ s_ !"#$%&'()*+,-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ c C s t | t| kS )N)chr_QUOPRI_HEADER_MAP)octetr r r header_checkJ s r c C s t | t| kS )N)r _QUOPRI_BODY_MAP)r r r r
body_checkO s r c C s t dd | D S )Nc s s | ]}t t| V qd S )N)lenr )r r r r r ^ s z header_length..)sum) bytearrayr r r r T s
c C s t dd | D S )Nc s s | ]}t t| V qd S )N)r r )r r r r r r! h s z body_length..)r" )r# r r r r a s c C sf t |tst|}| s&| j|j nn^|d |k r||d tkr||d tkr|t|||d 7 }|d7 }n||7 }|d7 }||kr>||7 }q>W qW | d dkr |j|r |d d }|S )
Nr r r: r$ r; r. z
r% r% )r> rstripr r r
endswith)r7 rA ZdecodedrB inr r r r r s8
,
c C s | j d}t|S )Nr )groupr
)matchr+ r r r _unquote_match s
rL c C s | j dd} tjdt| tjdS )Nr r z=[a-fA-F0-9]{2})flags)replaceresubrL ASCII)r+ r r r r # s )r )r3 ) __all__rO stringr r
r r? NLZ EMPTYSTRINGranger1 r r encoder r r2 r r r r r- r
r r r= r r r r rL r r r r r sN
O 0PK ! Ш7e% e% * __pycache__/generator.cpython-36.opt-2.pycnu [ 3
IiS @ s d ddgZ ddlZddlZddlZddlZddlmZ ddlmZm Z ddl
m Z ddl m
Z
d Zd
Zejd Zejd ejZejd
ZejdZG dd d ZG dd deZdZG dd deZeeej d Z de Z ej Z dS ) GeneratorDecodedGeneratorBytesGenerator N)deepcopy)StringIOBytesIO)_has_surrogates)HeaderWriteError_
z
\r\n|\r|\nz^From z \r\n[^ \t]|\r[^ \n\t]|\n[^ \t]s \r\n[^ \t]|\r[^ \n\t]|\n[^ \t]c @ s e Zd Zd&ddddZdd Zd'dd Zd
d Zd d
Zdd Zdd Z dd Z
dd Z dd Z dd Z
e
Zdd Zd d Zd d Zd d! Zed(d"d#Zed$d% ZdS ))r N)policyc C s6 |d kr|d krdn|j }|| _|| _|| _|| _d S )NT) mangle_from__fp
_mangle_from_ maxheaderlenr )selfoutfpr
r r r '/usr/lib64/python3.6/email/generator.py__init__' s zGenerator.__init__c C s | j j| d S )N)r write)r sr r r r G s zGenerator.writeFc C s | j d kr|j n| j }|d k r*|j|d}| jd k rB|j| jd}|j| _| j| j| _d| _| j| j| _| j }|j }zL|| _ ||_ |r|j }|sdt
j t
j
}| j || j | j
| W d || _ ||_ X d S )N)linesep)max_line_length z From nobody )r cloner r _NL_encode _encoded_NLZ_EMPTY_encoded_EMPTYZ get_unixfromtimeZctimer _write)r msgunixfromr r Zold_gen_policyZold_msg_policyZufromr r r flattenK s,
zGenerator.flattenc C s | j || jd | jdS )N)r ) __class__r r )r fpr r r r | s zGenerator.clonec C s t S )N)r )r r r r _new_buffer s zGenerator._new_bufferc C s |S )Nr )r r r r r r s zGenerator._encodec C sX |sd S t j|}x*|d d D ]}| j| | j| j q W |d rT| j|d d S )N r) r) )NLCREsplitr r )r linesliner r r _write_lines s
zGenerator._write_linesc C s | j }z"d | _| j | _ }| j| W d || _ | j}| `X |rht|}|jd|d |jd|d t|dd }|d kr| j| n|| | j j|j d S )Nzcontent-transfer-encodingr z content-typer( _write_headers)
r
_munge_cter' _dispatchr Zreplace_headergetattrr/ r getvalue)r r" ZoldfpZsfpZ munge_ctemethr r r r! s" zGenerator._writec C st |j }|j }tj||fjdd}t| d| d }|d krh|jdd}t| d| d }|d krh| j}|| d S )N-r
Z_handle_)get_content_maintypeget_content_subtype
UNDERSCOREjoinreplacer2
_writeBody)r r" mainsubZspecificr4 Zgenericr r r r1 s zGenerator._dispatchc C s x|j D ]\}}| jj||}| jjr| jj}|j| jjsRtd|d||}|j|rr|d t| }tj |rtd|| j
| q
W | j
| j d S )Nz folded header does not end with z: z folded header contains newline: ) raw_itemsr Zfoldverify_generated_headersr endswithr lenNEWLINE_WITHOUT_FWSPsearchr r )r r" hvfoldedr folded_no_linesepr r r r/ s
zGenerator._write_headersc C s |j }|d krd S t|ts.tdt| t|jr~|jd}|d k r~t|}|d= |j || |j }|d |d f| _
| j rt j
d|}| j| d S )Nzstring payload expected: %scharsetzcontent-transfer-encodingz content-typez>From ) get_payload
isinstancestr TypeErrortyper _payloadZ get_paramr Z set_payloadr0 r fcrer= r. )r r" payloadrH r r r _handle_text s"
zGenerator._handle_textc C s g }|j }|d krg }n(t|tr2| j| d S t|tsB|g}x>|D ]6}| j }| j|}|j|d| jd |j |j
qHW |j }|s| j j
|}| j|}|j| |jd k r| jrtjd|j} n|j} | j| | j| j | jd| | j |r| jj|jd x4|D ],}
| j| jd | | j | jj|
q W | j| jd | d | j |jd k r| jrtjd|j} n|j} | j| d S )NF)r# r z>From z--r )rI rJ rK r listr' r r$ r appendr3 Z get_boundaryr r9 _make_boundaryZ set_boundarypreambler rO r= r. r popepilogue) r r" ZmsgtextsZsubpartspartr gboundaryZalltextrU Z body_partrW r r r _handle_multipart
sJ
zGenerator._handle_multipartc C s0 | j }|jdd| _ z| j| W d || _ X d S )Nr )r )r r r[ )r r" pr r r _handle_multipart_signedG s
z"Generator._handle_multipart_signedc C s g }x|j D ]t}| j }| j|}|j|d| jd |j }|j| j}|rx|d | jkrx|j | jj
|d d q|j | qW | j j | jj
| d S )NF)r# r r( r) r) )
rI r' r r$ r r3 r+ r r rS r9 r r )r r" ZblocksrX r rY textr, r r r _handle_message_delivery_statusR s
z)Generator._handle_message_delivery_statusc C s^ | j }| j|}|j}t|trD|j|jdd| jd |j }n
| j |}| j
j | d S )Nr F)r# r ) r' r rN rJ rR r$ rI r r3 r r r )r r" r rY rP r r r _handle_messageg s
zGenerator._handle_messagec C sz t jtj}d t| d }|d kr(|S |}d}xD| jdtj| d tj}|j |sZP |d t
| }|d7 }q2W |S )
N= z==r z^--z(--)?$.r( z===============) randomZ randrangesysmaxsize_fmt _compile_rereescape MULTILINErC rK )clsr^ tokenrZ bZcounterZcrer r r rT s
zGenerator._make_boundaryc C s t j||S )N)ri compile)rl r flagsr r r rh s zGenerator._compile_re)NN)FN)N)__name__
__module__ __qualname__r r r$ r r' r r. r! r1 r/ rQ r; r[ r] r_ r` classmethodrT rh r r r r r s(
1#: c sL e Zd Zdd Zdd Zdd Zdd Z fd d
ZeZe d d Z
Z S )
r c C s | j j|jdd d S )Nasciisurrogateescape)r r encode)r r r r r r s zBytesGenerator.writec C s t S )N)r )r r r r r' s zBytesGenerator._new_bufferc C s
|j dS )Nru )rw )r r r r r r s zBytesGenerator._encodec C s x|j D ]\}}| jj||}| jjr| jjj }|j|sRtd|d||}|j|rr|d t| }t j
|rtd|| j j | q
W | j | j
d S )Nz folded header does not end with z: z folded header contains newline: )r> r Z fold_binaryr? r rw r@ r rA NEWLINE_WITHOUT_FWSP_BYTESrC r r r )r r" rD rE rF r rG r r r r/ s
z BytesGenerator._write_headersc s^ |j d krd S t|j rJ| jjdk rJ| jrFrom ) rN r r Zcte_typer rO r= r. superr rQ )r r" )r% r r rQ s
zBytesGenerator._handle_textc C s t j|jd|S )Nru )ri ro rw )rl r rp r r r rh s zBytesGenerator._compile_re) rq rr rs r r' r r/ rQ r; rt rh
__classcell__r r )r% r r s
zD[Non-text (%(type)s) part of message omitted, filename %(filename)s]c @ s$ e Zd ZdddddZdd ZdS )r N)r c C s. t j| ||||d |d kr$t| _n|| _d S )N)r )r r _FMTrg )r r r
r Zfmtr r r r r s
zDecodedGenerator.__init__c C s x|j D ]v}|j }|dkr4t|jdd| d q
|dkr>q
t| j|j |j |j |jd|jdd|jd d
d | d q
W d S ) Nr^ F)decode)fileZ multipartz
[no filename]zContent-Descriptionz[no description]zContent-Transfer-Encodingz
[no encoding])rM maintypesubtypefilenameZ descriptionencoding) walkr6 printrI rg Zget_content_typer7 get_filenameget)r r" rX r~ r r r r1 s
zDecodedGenerator._dispatch)NNN)rq rr rs r r1 r r r r r s r( z%%0%dd) __all__ri re r rd copyr ior r Z email.utilsr Z email.errorsr r8 NLro r* rk rO rB rx r r r{ r rA reprrf Z_widthrg rT r r r r s.
|?;PK ! +M
* __pycache__/iterators.cpython-36.opt-2.pycnu [ 3
\W @ sH d ddgZ ddlZddlmZ dd Zd
dd Zdd
dZdd d ZdS )body_line_iteratortyped_subpart_iteratorwalk N)StringIOc c s2 | V | j r.x | j D ]}|j E d H qW d S )N) is_multipart get_payloadr )selfsubpart r
'/usr/lib64/python3.6/email/iterators.pyr s Fc c s: x4| j D ](}|j|d}t|tr
t|E d H q
W d S )N)decode)r r
isinstancestrr )msgr r Zpayloadr
r
r r " s
textc c s< x6| j D ]*}|j |kr
|d ks.|j |kr
|V q
W d S )N)r Zget_content_maintypeZget_content_subtype)r Zmaintypesubtyper r
r
r r - s c C s |d krt j}d|d }t|| j d|d |rJtd| j |d n
t|d | j rx"| j D ]}t|||d | qfW d S )N )endfilez [%s])r )sysstdoutprintZget_content_typeZget_default_typer r
_structure)r fplevelZinclude_defaultZtabr r
r
r r ; s
r )F)r N)Nr F)__all__r ior r r r r r
r
r
r s
PK ! " ( __pycache__/charset.cpython-36.opt-2.pycnu [ 3
\B @ sr d dddgZ ddlmZ ddlZddlZddlmZ ddlmZ d Z d
Z
d Z d Z d
Z
dZdZe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfe e dfd*e
e
dfe
e
dfe
ddfe
ddfe
ddfe
e
dfe e
dfdZddddddddddddddddddd d d d d d
d Zd!d"dd#Zd+d$dZd%d Zd&d Zd'd( ZG d)d d ZdS ),Charset add_alias add_charset add_codec )partialN)errors)encode_7or8bit zus-asciiz unknown-8bit z iso-2022-jpzutf-8)z
iso-8859-1z
iso-8859-2z
iso-8859-3z
iso-8859-4z
iso-8859-9z iso-8859-10z iso-8859-13z iso-8859-14z iso-8859-15z iso-8859-16z windows-1252Zvisciizus-asciibig5gb2312zeuc-jp shift_jisz iso-2022-jpzkoi8-rzutf-8z
iso-8859-1z
iso-8859-2z
iso-8859-3z
iso-8859-4z
iso-8859-9z iso-8859-10z iso-8859-13z iso-8859-14z iso-8859-15z iso-8859-16zks_c_5601-1987zeuc-jpzeuc-kr)latin_1zlatin-1Zlatin_2zlatin-2Zlatin_3zlatin-3Zlatin_4zlatin-4Zlatin_5zlatin-5Zlatin_6zlatin-6Zlatin_7zlatin-7Zlatin_8zlatin-8Zlatin_9zlatin-9Zlatin_10zlatin-10cp949euc_jpeuc_krascii eucgb2312_cnbig5_tw)r r zus-asciic C s" |t krtd|||ft| < d S )Nz!SHORTEST not allowed for body_enc)SHORTEST
ValueErrorCHARSETS)charsetZ
header_encZbody_encoutput_charset r %/usr/lib64/python3.6/email/charset.pyr m s c C s |t | < d S )N)ALIASES)aliasZ canonicalr r r r s c C s |t | < d S )N) CODEC_MAP)r Z codecnamer r r r s c C s" |t kr| jddS | j|S d S )Nr surrogateescape) UNKNOWN8BITencode)stringcodecr r r _encode s r' c @ s\ e Zd ZefddZdd ZeZdd Zdd Zd d
Z d d Z
d
d Z dd Z dd Z
dS )r c
C s y$t |tr|jd n
t|d}W n tk
rB tj|Y nX |j }tj||| _ t
j| j t t d f\}}}|s~| j }|| _
|| _tj||| _tj| j | j | _tj| j| j| _d S )Nr )
isinstancestrr$ UnicodeErrorr Z CharsetErrorlowerr get
input_charsetr r BASE64header_encoding
body_encodingr r! Z input_codec output_codec)selfr- ZhencZbencZconvr r r __init__ s&
zCharset.__init__c C s
| j j S )N)r- r+ )r2 r r r __str__ s zCharset.__str__c C s t | t |j kS )N)r) r+ )r2 otherr r r __eq__ s zCharset.__eq__c C s$ | j tkrdS | j tkr dS tS d S )Nzquoted-printablebase64)r0 QPr. r )r2 r r r get_body_encoding s
zCharset.get_body_encodingc C s | j p
| jS )N)r r- )r2 r r r get_output_charset s zCharset.get_output_charsetc C s6 | j pd}t||}| j|}|d kr*|S |j||S )Nzus-ascii)r1 r' _get_encoder
header_encode)r2 r% r& header_bytesencoder_moduler r r r< s
zCharset.header_encodec C s | j pd}t||}| j|}t|j|d}| j }t|t }g } g }
t|| } x|D ]} |
j | t
j |
}
|j t|
|}|| krZ|
j
| r|
r| j d n.| rdnd}t
j |
}t||}| j || | g}
t|| } qZW t
j |
}t||}| j || | S )Nzus-ascii)r r
)r1 r' r; r r< r: lenRFC2047_CHROME_LENnextappend EMPTYSTRINGjoin
header_lengthpop)r2 r% Z
maxlengthsr& r= r> encoderr ZextralinesZ current_linemaxlen characterZ this_lineZlengthZ separatorZ joined_liner r r header_encode_lines, s6
zCharset.header_encode_linesc C s` | j tkrtjS | j tkr tjS | j tkrXtjj|}tjj|}||k rPtjS tjS nd S d S )N)r/ r. email
base64mimer8
quoprimimer rF )r2 r= Zlen64Zlenqpr r r r; j s
zCharset._get_encoderc C s |s|S | j tkr4t|tr(|j| j}tjj|S | j t krjt|trT|j| j}|j
d}tj j|S t|tr|j| jj
d}|S d S )Nlatin1r ) r0 r. r( r) r$ r rM rN body_encoder8 decoderO )r2 r% r r r rQ y s
zCharset.body_encodeN)__name__
__module__ __qualname__DEFAULT_CHARSETr3 r4 __repr__r6 r9 r: r< rL r; rQ r r r r r s , !>)NNN)NNN)__all__ functoolsr Zemail.base64mimerM Zemail.quoprimimer Zemail.encodersr r8 r. r rA rV r# rD r r r! r r r r' r r r r r s
PK ! b@ b@ ! __pycache__/header.cpython-36.pycnu [ 3
\&^ @ s d Z dddgZddlZddlZddlZddlZddlmZ ddlm Z
e
j Z dZ d Z
d
ZdZd Zd
ZdZe dZe dZejdejejB ejB ZejdZejdZej j Z dd Z d ddZ G dd dZ G dd dZ!G dd de"Z#dS ) z+Header encoding and decoding functionality.Header
decode_header make_header N)HeaderParseError)charset
N z zus-asciizutf-8ai
=\? # literal =?
(?P[^?]*?) # non-greedy up to the next ? is the charset
\? # literal ?
(?P[qb]) # either a "q" or a "b", case insensitive
\? # literal ?
(?P.*?) # non-greedy up to the next ?= is the encoded string
\?= # literal ?=
z[\041-\176]+:$z
\n[^ \t]+:c C s t | drdd | jD S tj| s.| dfgS g }x| j D ]}tj|}d}xp|r|jd}|rn|j }d}|r|j|ddf |rP|jdj }|jdj }|jd}|j|||f qPW qM s z!decode_header..NTr F qb z===zBase64 decoding errorzUnexpected encoding: zraw-unicode-escape)hasattrr
ecresearch
splitlinessplitpoplstripappendlower enumerateisspacereversedemail
quoprimimeZ
header_decodelenZ
base64mimedecodebinasciiErrorr AssertionError
isinstancer bytesBSPACE)headerZwordslinepartsfirstZ unencodedr encodingZencodedZdroplistnwdZ
decoded_wordsZencoded_stringZwordZpaderrZ collapsedZ last_word last_charsetr r r r = sz
4
c C sL t |||d}x8| D ]0\}}|dk r8t|t r8t|}|j|| qW |S )a Create a Header from a sequence of pairs as returned by decode_header()
decode_header() takes a header value string and returns a sequence of
pairs of the format (decoded_string, charset) where charset is the string
name of the character set.
This function takes one of those sequence of pairs and returns a Header
instance. Optional maxlinelen, header_name, and continuation_ws are as in
the Header constructor.
)
maxlinelen header_namecontinuation_wsN)r r- Charsetr! )Z decoded_seqr9 r: r; hsr r r r r s c @ sJ e Zd ZdddZdd Zdd Zdd
d Zd d
ZdddZdd Z dS )r Nr strictc C s| |dkrt }nt|ts t|}|| _|| _g | _|dk rH| j||| |dkrTt}|| _|dkrjd| _ nt
|d | _ dS )aD Create a MIME-compliant header that can contain many character sets.
Optional s is the initial header value. If None, the initial header
value is not set. You can later append to the header with .append()
method calls. s may be a byte string or a Unicode string, but see the
.append() documentation for semantics.
Optional charset serves two purposes: it has the same meaning as the
charset argument to the .append() method. It also sets the default
character set for all subsequent .append() calls that omit the charset
argument. If charset is not provided in the constructor, the us-ascii
charset is used both as s's initial charset and as the default for
subsequent .append() calls.
The maximum line length can be specified explicitly via maxlinelen. For
splitting the first line to a shorter value (to account for the field
header which isn't included in s, e.g. `Subject') pass in the name of
the field in header_name. The default maxlinelen is 78 as recommended
by RFC 2822.
continuation_ws must be RFC 2822 compliant folding whitespace (usually
either a space or a hard tab) which will be prepended to continuation
lines.
errors is passed through to the .append() call.
Nr r ) USASCIIr- r< r _continuation_wsr
r!
MAXLINELEN _maxlinelen
_headerlenr( )selfr> r r9 r: r; errorsr r r __init__ s
zHeader.__init__c C s | j g }d}d}x| jD ]\}}|}|tjkrJ|jdd}|jdd}|r|o^| j|d }|dkr|d kr| r|jt d}n|d
kr| r|jt |o| j|d }|}|j| q W t j
|S ) z&Return the string value of the header.Nasciisurrogateescapereplacer us-asciir )NrK )NrK )NrK )
_normalizer
r UNKNOWN8BITencoder) _nonctextr! SPACE EMPTYSTRINGjoin) rE Zuchunkslastcs lastspacer r ZnextcsZoriginal_byteshasspacer r r __str__ s*
zHeader.__str__c C s |t | kS )N)r )rE otherr r r __eq__ s z
Header.__eq__c C s |dkr| j }nt|ts"t|}t|tsZ|jp4d}|t jkrN|jdd}n |j||}|jpbd}|t jkry|j|| W n" t k
r |dkr t
}Y nX | j j ||f dS )a. Append a string to the MIME header.
Optional charset, if given, should be a Charset instance or the name
of a character set (which will be converted to a Charset instance). A
value of None (the default) means that the charset given in the
constructor is used.
s may be a byte string or a Unicode string. If it is a byte string
(i.e. isinstance(s, str) is false), then charset is the encoding of
that byte string, and a UnicodeError will be raised if the string
cannot be decoded with that charset. If s is a Unicode string, then
charset is a hint specifying the character set of the characters in
the string. In either case, when producing an RFC 2822 compliant
header using RFC 2047 rules, the string will be encoded using the
output codec of the charset. If the string cannot be encoded to the
output codec, a UnicodeError will be raised.
Optional `errors' is passed as the errors argument to the decode
call if s is a byte string.
Nzus-asciirI )
r r- r< r Z input_codecrN r) Z output_codecrO UnicodeEncodeErrorUTF8r
r! )rE r> r rF Z
input_charsetZoutput_charsetr r r r! s$
z
Header.appendc C s |j p|dkS )z=True if string s is not a ctext character of RFC822.
()\)r\ r] r^ )r$ )rE r> r r r rP 4 s zHeader._nonctext;, r c C s | j |dkr| j}|dkr"d}t| j|| j|}d}d }}x4| jD ](\}} |dk r|ol| j|d }|d
kr| s| d kr|j n| d kr| r|j |o| j|d
}| }d}|j }
|
r|j d|
d | n|j dd| xr|
dd D ]b} |j
| j dk r,|j | jd| j | n.| j } | dt
| t
| }
|j |
| | qW t
|
dkrJ|j
qJW | jr|j |j|}tj|rtd j||S )a Encode a message header into an RFC-compliant format.
There are many issues involved in converting a given string for use in
an email header. Only certain character sets are readable in most
email clients, and as header strings can only contain a subset of
7-bit ASCII, care must be taken to properly convert and encode (with
Base64 or quoted-printable) header strings. In addition, there is a
75-character length limit on any given encoded header field, so
line-wrapping must be performed, even with double-byte character sets.
Optional maxlinelen specifies the maximum length of each generated
line, exclusive of the linesep string. Individual lines may be longer
than maxlinelen if a folding point cannot be found. The first line
will be shorter by the length of the header name plus ": " if a header
name was specified at Header construction time. The default value for
maxlinelen is determined at header construction time.
Optional splitchars is a string containing characters which should be
given extra weight by the splitting algorithm during normal header
wrapping. This is in very rough support of RFC 2822's `higher level
syntactic breaks': split points preceded by a splitchar are preferred
during line splitting, with the characters preferred in the order in
which they appear in the string. Space and tab may be included in the
string to indicate whether preference should be given to one over the
other as a split point when other split chars do not appear in the line
being split. Splitchars does not affect RFC 2047 encoded lines.
Optional linesep is a string to be used to separate the lines of
the value. The default value is the most useful for typical
Python applications, but it can be set to \r\n to produce RFC-compliant
line separators when needed.
Nr i@B us-asciir Fr r z8header value appears to contain an embedded header: {!r})Nr` )Nr` )Nr` rL )rM rC _ValueFormatterrD rA r
rP add_transitionr feednewlineheader_encodingr r( _str_embedded_headerr r format)rE
splitcharsr9 linesepZ formatterrT rV rU r r linesr1 Zslinefwsvaluer r r rO 9 sR !
z
Header.encodec C s| g }d }g }xL| j D ]B\}}||kr0|j| q|d k rL|jtj||f |g}|}qW |rr|jtj||f || _ d S )N)r
r! rQ rS )rE Zchunksr8 Z
last_chunkr r r r r rM s zHeader._normalize)NNNNr r? )Nr? )r_ Nr )
__name__
__module__ __qualname__rG rW rY r! rP rO rM r r r r r s
-
+
Pc @ sT e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dS )ra c C s0 || _ || _t|| _|| _g | _t|| _d S )N)_maxlenrA r( _continuation_ws_len _splitchars_lines _Accumulator
_current_line)rE Z headerlenmaxlenr; ri r r r rG s
z_ValueFormatter.__init__c C s | j |j| jS )N)rd rS rt )rE rj r r r rf s z_ValueFormatter._strc C s
| j tS )N)rf NL)rE r r r rW s z_ValueFormatter.__str__c C sp | j j }|dkr | j j| t| j dkrb| j j rP| jd t| j 7 < n| jjt| j | j j d S )Nr r r r )r r rL ) rv r pushr( is_onlywsrt r r! reset)rE Z end_of_liner r r rd s
z_ValueFormatter.newlinec C s | j jdd d S )Nr r )rv ry )rE r r r rb s z _ValueFormatter.add_transitionc C s |j d kr | j||| j d S |j|| j }y|jd}W n tk
rP d S X |d k rf| j|| y |j }W n tk
r d S X | j | j j
| j | x |D ]}| j j
| j | qW d S )Nr )re _ascii_splitrs Zheader_encode_lines _maxlengthsr
IndexError
_append_chunkrd rv ry rA rt r! )rE rl r r Z
encoded_linesZ
first_line last_liner1 r r r rc s$
z_ValueFormatter.feedc c s* | j t| j V x| j | j V qW d S )N)rq r( rv rr )rE r r r r} s z_ValueFormatter._maxlengthsc C sj t jdt d || }|d r0dg|d d< n
|jd x*tt|gd D ]\}}| j|| qNW d S )Nz([z]+)r r r )rer FWSr zipiterr )rE rl r ri r2 partr r r r| s
z _ValueFormatter._ascii_splitc C s
| j j|| t| j | jkrx| jD ]t}xlt| j j d ddD ]P}|j rp| j | d }|rp|d |krpP | j |d d }|rD|d |krDP qDW q(P q(W | j j \}}| j j dkr| j
|sd}| j j|| d S | j j |}| j j
t| j | j j| d S )Nr r r rL rL )rv ry r( rq rs range
part_countr$ r
_initial_sizerd pop_fromrt r! r r{ )rE rl r ZchiZprevpartr Z remainderr r r r s. z _ValueFormatter._append_chunkN) rn ro rp rG rf rW rd rb rc r} r| r r r r r ra s %ra c sj e Zd Zd fdd Zdd ZdddZ fdd Zd
d Zd d
ZdddZ dd Z
fddZ Z S )ru r c s || _ t j d S )N)r superrG )rE Z initial_size) __class__r r rG s z_Accumulator.__init__c C s | j ||f d S )N)r! )rE rl r r r r ry # s z_Accumulator.pushc C s | |d }g | |d < |S )Nr )rE r Zpoppedr r r r & s z_Accumulator.pop_fromc s | j dkrdS t j S )Nr r )r r )r r r )rE )r r r r + s z_Accumulator.popc C s t dd | D | jS )Nc s s" | ]\}}t |t | V qd S )N)r( )r rl r r r r 1 s z'_Accumulator.__len__..)sumr )rE r r r __len__0 s z_Accumulator.__len__c C s t jdd | D S )Nc s s | ]\}}t j||fV qd S )N)rR rS )r rl r r r r r 5 s z'_Accumulator.__str__..)rR rS )rE r r r rW 4 s
z_Accumulator.__str__Nc C s" |d kr g }|| d d < d| _ d S )Nr )r )rE Zstartvalr r r r{ 8 s z_Accumulator.resetc C s | j dko| pt| j S )Nr )r r r$ )rE r r r rz > s z_Accumulator.is_onlywsc s
t j S )N)r r )rE )r r r r A s z_Accumulator.part_count)r )r )N)
rn ro rp rG ry r r r rW r{ rz r
__classcell__r r )r r ru s
ru z )NNr )$__doc____all__r r* Zemail.quoprimimer& Zemail.base64mimeZ email.errorsr r r r< rx rQ r/ ZSPACE8rR rB r r@ r[ compileVERBOSE
IGNORECASE MULTILINEr Zfcrerg r' Z _max_appendr r r ra listru r r r r s@
_
k PK ! b$ $ & __pycache__/utils.cpython-36.opt-2.pycnu [ 3
IiJ @ s d ddddddddd d
d d d
dgZ ddlZddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl m
Z
ddl mZmZmZ ddlmZ dZdZdZdZdZejdZejdZd Zda d d Z d d Z d!d" Z d#d$ Z dHd&dZ!d'd( Z"d)d* Z#d+Z$dd,d-dZ%d.d/ Z&d0d1 Z'd2d3 Z(ejd4ej)ej*B Z+d5d6 Z,dId8dZ-dJd9dZ.dKd:dZ/d;d
Z0dd,dd Z3dLd?dZ4ejd@ej5Z6dAd Z7dMdDd Z8dOdFdGZ9dS )Pcollapse_rfc2231_value
decode_paramsdecode_rfc2231encode_rfc2231
formataddr
formatdateformat_datetime getaddresses
make_msgid mktime_tz parseaddr parsedate parsedate_tzparsedate_to_datetimeunquote N)quote) AddressList)r
)r r
_parsedate_tz)Charsetz, z
'z[][\\()<>@,:;".]z[\\"]z/etc/python/email.cfgc C s t d krt a t S )N)_cached_strict_addr_parsing _use_strict_email_parsing_impl r r #/usr/lib64/python3.6/email/utils.py_use_strict_email_parsing7 s r c C s t tjjd} | rdS y tt}W n tk
r8 Y nBX |6 dd l}|jd d d}|j | |j
ddd d} W d Q R X | rdS dS )
NZ(PYTHON_EMAIL_DISABLE_STRICT_ADDR_PARSINGFr #)Z
interpolationZcomment_prefixesZemail_addr_parsing)ZfallbackT)r ) boolosenvirongetopen_EMAIL_CONFIG_FILEFileNotFoundError configparserZ ConfigParserZ read_fileZ
getboolean)Zdisabledfiler$ configr r r r ? s"
r c C s& y | j dS tk
r dS X d S )NFT)encodeUnicodeEncodeError)sr r r _has_surrogates\ s
r* c C s | j dd}|jddS )Nzutf-8surrogateescapereplace)r' decode)stringZoriginal_bytesr r r _sanitizei s r/ utf-8c
C s | \}}|j d |ry|j d W n8 tk
r\ t|trFt|}|j|}d||f S X d}tj|rpd}tj d|}d||||f S |S )Nasciiz%s <%s>r "z\\\g<0>z %s%s%s <%s>)
r' r(
isinstancestrr Z
header_encode
specialsresearch escapesresub)ZpaircharsetnameZaddressZ encoded_nameZquotesr r r r u s
c c s` d}d}xDt | D ]8\}}|r2|d| fV d}q|dkr@d}q||fV qW |r\|dfV d S )Nr F\T) enumerate)addrposescapechr r r _iter_escaped_chars s rA c C s d| kr | S d}d }g }xPt | D ]D\}}|dkr"|d kr@|}q"||krZ|j| || |d }d }q"W |t| k r|j| |d dj|S )Nr2 r r )rA appendlenjoin)r= startZopen_posresultr> r@ r r r _strip_quoted_realnames s rH T)strictc C s |d krt }|s4tjdd | D }t|}|jS dd | D } t| } tj| }t|}t|j}d}x&| D ] }t|}|d|jd 7 }qpW t ||krd gS |S )
Nc s s | ]}t |V qd S )N)r4 ).0vr r r s z getaddresses..c S s g | ] }t |qS r )r4 )rJ rK r r r
s z getaddresses..r rB ,r )r r )
r
COMMASPACErE _AddressList addresslist_pre_parse_validation_post_parse_validationrH countrD )Z fieldvaluesrI allar= rG nrK r r r r s$
c C sX t | } d}xBt| D ]6\}}|dkr0|d7 }q|dkr|d8 }|dk rdS qW |dkS )Nr (rB )F)rH rA )r= Zopensr> r@ r r r _check_parenthesis s
rZ c C s, g }x"| D ]}t |sd}|j| q
W |S )Nz('', ''))rZ rC )Zemail_header_fieldsaccepted_valuesrK r r r rR s
rR c C s0 g }x&| D ] }d|d kr d}|j | q
W |S )N[rB r )r r )rC )Zparsed_email_header_tuplesr[ rK r r r rS
s
rS a_
=\? # literal =?
(?P[^?]*?) # non-greedy up to the next ? is the charset
\? # literal ?
(?P[qb]) # either a "q" or a "b", case insensitive
\? # literal ?
(?P.*?) # non-greedy up to the next ?= is the atom
\?= # literal ?=
c C sf ddddddddg| d | d
d d d
dddddddddg | d d | d | d | d | d |f S ) Nz"%s, %02d %s %04d %02d:%02d:%02d %sZMonZTueZWedZThuZFriZSatZSun ZJanZFebZMarZAprZMayZJunZJulZAugZSepZOctZNovZDecrB r r ) timetuplezoner r r _format_timetuple_and_zone" s rd Fc C sR | d krt j } |s|r,tjj| tjj}n tjj| }|rH|j }d}t||S )NF)timedatetimeZ
fromtimestamptimezoneutcZutcfromtimestamp
astimezoner )timeval localtimeusegmtdtr r r r + s c C sV | j }|r2| jd ks$| jtjjkr,tdd}n| jd krBd}n
| jd}t||S )Nz%usegmt option requires a UTC datetimeZGMTz-0000z%z)rb tzinforf rg rh
ValueErrorZstrftimerd )rm rl nowrc r r r r H s
c C s^ t tj d }tj }tjd}| d kr0d} nd| } |d krHtj }d|||| |f }|S )Nd @ r .z<%d.%d.%d%s@%s>)intre r getpidrandomZ getrandbitssocketZgetfqdn)ZidstringZdomainrj pidZrandintZmsgidr r r r [ s
c C sN t | ^ }}|d kr(tj|d d S tj|d d dtjtj|diS )Nr] rn )seconds)r rf rg timedelta)dataZdtupletzr r r r r s
c C s |d krt }|s,t| j}|s$dS |d S t| tr>| d } t| tsLdS t| gd } tt| j}| szt|dkr~dS |d S )Nr r rB )r r )r r )r r ) r rP rQ r3 listr4 rR rS rD )r= rI Zaddrsr r r r z s
c C s` t | dkr\| jdr<| jdr<| dd jddjddS | jdr\| jdr\| dd S | S )
NrB r2 z\\r; z\"<>r )rD
startswithendswithr, )r4 r r r r s c C s& | j td}t|dkr"d d | fS |S )Nr^ )splitTICKrD )r) partsr r r r s
c C sD t jj| d|pdd} |d kr*|d kr*| S |d kr6d}d||| f S )Nr r1 )Zsafeencodingz%s'%s'%s)urllibparser )r) r9 languager r r r s z&^(?P\w+)\*((?P[0-9]+)\*?)?$c
C sx | d d } g }i }| j d\}}|j||f x| r| j d\}}|jdrTd}nd}t|}tj|}|r|jdd\}}|d k rt|}|j|g j|||f q2|j|dt | f q2W |rtx|j
D ]\}}g }d} |j x6|D ].\}}
}|rt j
j|
dd }
d} |j|
qW t tj|}| r^t|\} } }|j|| | d| ff q|j|d| f qW |S )
Nr *TFr: numz"%s"zlatin-1)r )poprC r r rfc2231_continuationmatchgrouprt
setdefaultr itemssortr r EMPTYSTRINGrE r )
ZparamsZ
new_paramsZrfc2231_paramsr: valueZencodedZmor Z
continuationsZextendedr) r9 r r r r r sD
r, us-asciic C sj t | t st| dkr t| S | \}}}|d kr6|}t|d}y t|||S tk
rd t|S X d S )Nr_ zraw-unicode-escape)r3 tuplerD r bytesr4 LookupError)r errorsZfallback_charsetr9 r textZrawbytesr r r r s
rB c C s | d kr t j jt jjj S | jd k r.| j S | j d d |f }tj|}tj |}y t j
|j d}t j||j }W n t
k
r | t j tj|d d }tjo|jdk}|rtjntj }|t j
|dkrt j|tj| }n
t j|}Y nX | j|dS )NrB )ry r] r )rn r )rf rp rg rh ri rn rb re Zmktimerk rz Z tm_gmtoffZtm_zoneAttributeErrorZgmtimeZdaylightZtm_isdstZaltzoneZtznamer, ) rm ZisdstZtmry ZlocaltmZdeltar| dstZgmtoffr r r rk s$
rk )r0 )NFF)F)NN)NN)r, r r )Nr ):__all__r rere rv rw rf Z urllib.parser Zemail._parseaddrr r rP r
r r
r Z
email.charsetr rO r Z UEMPTYSTRINGZCRLFr compiler5 r7 r" r r r r* r/ r rA rH Zsupports_strict_parsingr rZ rR rS VERBOSE
IGNORECASEZecrerd r r r r r r r r ASCIIr r r rk r r r r s
!1
$
8
PK ! J) ) / __pycache__/_header_value_parser.cpython-36.pycnu [ 3
Ii @ sz d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z ddl m Z ddl m
Z
ed Zeed
B Zed ZeeB Zeed Zeed
ZeedB ed ZeeB ZeedB ZeeB Zeed ZddhZeeB Zdd Z G dd de Z G dd de Z G dd de Z G dd d e Z!G d d d e Z"G d d d e Z#G d!d" d"e Z$G d#d$ d$e Z%G d%d& d&e Z&G d'd( d(e Z'G d)d* d*e'Z(G d+d, d,e Z)G d-d. d.e Z*G d/d0 d0e Z+G d1d2 d2e Z,G d3d4 d4e Z-G d5d6 d6e Z.G d7d8 d8e Z/G d9d: d:e Z0G d;d< d d>e Z2G d?d@ d@e Z3G dAdB dBe Z4G dCdD dDe Z5G dEdF dFe Z6G dGdH dHe Z7G dIdJ dJe Z8G dKdL dLe!Z9G dMdN dNe Z:G dOdP dPe Z;G dQdR dRe ZG dWdX dXe Z?G dYdZ dZe Z@G d[d\ d\e ZAG d]d^ d^e ZBG d_d` d`e ZCG dadb dbeCZDG dcdd ddeCZEG dedf dfe ZFG dgdh dhe ZGG didj dje ZHG dkdl dleIZJG dmdn dneJZKG dodp dpeJZLG dqdr dreKZMeLd dsZNeLdtduZOeLdvdwZPejQdxjRdyjSejTZUejQdzjRdyjSejVd{d|jVd}d~jWZXejQdjYZZejQdzjRdyjSejVd{d|jVd}d~jWZ[ejQdzjRdyjSejVd{d|jVd}d~jWZ\ejQdzjRdyjSejVd{d|jVd}d~jWZ]dd Z^dd Z_dd Z`dd Zadd Zbdd Zcdd Zddd Zedd Zfdd Zgdd Zhdd Zidd Zjdd Zkdd Zldd Zmdd Zndd Zodd Zpdd Zqdd Zrdd Zsdd Ztdd Zudd Zvdd Zwdd Zxdd Zydd Zzdd Z{dd Z|dd Z}dd Z~ddÄ Zddń ZddDŽ ZddɄ Zdd˄ Zdd̈́ Zddτ Zddф Zddӄ ZddՄ Zddׄ Zddل Zddۄ Zdd݄ Zdd߄ Zdd Zdd Zdd Zdd Zdd Zdd Zdd ZdS )al Header value parser implementing various email-related RFC parsing rules.
The parsing methods defined in this module implement various email related
parsing rules. Principal among them is RFC 5322, which is the followon
to RFC 2822 and primarily a clarification of the former. It also implements
RFC 2047 encoded word decoding.
RFC 5322 goes to considerable trouble to maintain backward compatibility with
RFC 822 in the parse phase, while cleaning up the structure on the generation
phase. This parser supports correct RFC 5322 generation by tagging white space
as folding white space only when folding is allowed in the non-obsolete rule
sets. Actually, the parser is even more generous when accepting input than RFC
5322 mandates, following the spirit of Postel's Law, which RFC 5322 encourages.
Where possible deviations from the standard are annotated on the 'defects'
attribute of tokens that deviate.
The general structure of the parser follows RFC 5322, and uses its terminology
where there is a direct correspondence. Where the implementation requires a
somewhat different structure than that used by the formal grammar, new terms
that mimic the closest existing terms are used. Thus, it really helps to have
a copy of RFC 5322 handy when studying this code.
Input to the parser is a string that has already been unfolded according to
RFC 5322 rules. According to the RFC this unfolding is the very first step, and
this parser leaves the unfolding step to a higher level message parser, which
will have already detected the line breaks that need unfolding while
determining the beginning and end of each header.
The output of the parser is a TokenList object, which is a list subclass. A
TokenList is a recursive data structure. The terminal nodes of the structure
are Terminal objects, which are subclasses of str. These do not correspond
directly to terminal objects in the formal grammar, but are instead more
practical higher level combinations of true terminals.
All TokenList and Terminal objects have a 'value' attribute, which produces the
semantically meaningful value of that part of the parse subtree. The value of
all whitespace tokens (no matter how many sub-tokens they may contain) is a
single space, as per the RFC rules. This includes 'CFWS', which is herein
included in the general class of whitespace tokens. There is one exception to
the rule that whitespace tokens are collapsed into single spaces in values: in
the value of a 'bare-quoted-string' (a quoted-string with no leading or
trailing whitespace), any whitespace that appeared between the quotation marks
is preserved in the returned value. Note that in all Terminal strings quoted
pairs are turned into their unquoted values.
All TokenList and Terminal objects also have a string value, which attempts to
be a "canonical" representation of the RFC-compliant form of the substring that
produced the parsed subtree, including minimal use of quoted pair quoting.
Whitespace runs are not collapsed.
Comment tokens also have a 'content' attribute providing the string found
between the parens (including any nested comments) with whitespace preserved.
All TokenList and Terminal objects have a 'defects' attribute which is a
possibly empty list all of the defects found while creating the token. Defects
may appear on any token in the tree, and a composite list of all defects in the
subtree is available through the 'all_defects' attribute of any node. (For
Terminal notes x.defects == x.all_defects.)
Each object in a parse tree is called a 'token', and each has a 'token_type'
attribute that gives the name from the RFC 5322 grammar that it represents.
Not all RFC 5322 nodes are produced, and there is one non-RFC 5322 node that
may be produced: 'ptext'. A 'ptext' is a string of printable ascii characters.
It is returned in place of lists of (ctext/quoted-pair) and
(qtext/quoted-pair).
XXX: provide complete list of token types.
N) hexdigits) OrderedDict)
itemgetter)_encoded_words)errors)utilsz (z
()<>@,:;.\"[].z."(z/?=z*'%%
c C s dt | jddjdd d S )N"\z\\z\")strreplace)value r 2/usr/lib64/python3.6/email/_header_value_parser.py quote_stringb s r c s e Zd ZdZdZdZ fddZdd Z fddZe d d
Z
e d d Z d
d Z e dd Z
e dd Zdd Zd ddZd ddZd ddZ ZS ) TokenListNTc s t j|| g | _d S )N)super__init__defects)selfargskw) __class__r r r o s zTokenList.__init__c C s dj dd | D S )N c s s | ]}t |V qd S )N)r ).0xr r r t s z$TokenList.__str__..)join)r r r r __str__s s zTokenList.__str__c s dj | jjt j S )Nz{}({}))formatr __name__r __repr__)r )r r r r% v s
zTokenList.__repr__c C s dj dd | D S )Nr c s s | ]}|j r|j V qd S )N)r )r r r r r r | s z"TokenList.value..)r! )r r r r r z s zTokenList.valuec C s t dd | D | jS )Nc s s | ] }|j V qd S )N) all_defects)r r r r r r s z(TokenList.all_defects..)sumr )r r r r r& ~ s zTokenList.all_defectsc C s | d j S )Nr )startswith_fws)r r r r r( s zTokenList.startswith_fwsc C s t dd | D S )zATrue if all top level tokens of this part may be RFC2047 encoded.c s s | ] }|j V qd S )N)
as_ew_allowed)r partr r r r s z*TokenList.as_ew_allowed..)all)r r r r r) s zTokenList.as_ew_allowedc C s" g }x| D ]}|j |j q
W |S )N)extendcomments)r r- tokenr r r r- s
zTokenList.commentsc C s t | |dS )N)policy)_refold_parse_tree)r r/ r r r fold s zTokenList.foldr c C s t | j|d d S )N)indent)printppstr)r r2 r r r pprint s zTokenList.pprintc C s dj | j|dS )Nr )r2 )r! _pp)r r2 r r r r4 s zTokenList.ppstrc c s~ dj || jj| jV x<| D ]4}t|ds<|dj | V q |j|d E d H q W | jrhdj | j}nd}dj ||V d S )Nz{}{}/{}(r6 z* !! invalid element in token list: {!r}z z Defects: {}r z{}){})r# r r$
token_typehasattrr6 r )r r2 r. Zextrar r r r6 s
z
TokenList._pp)r )r )r )r$
__module__ __qualname__r7 syntactic_breakew_combine_allowedr r" r% propertyr r& r( r) r- r1 r5 r4 r6
__classcell__r r )r r r i s
r c @ s$ e Zd Zedd Zedd ZdS )WhiteSpaceTokenListc C s dS )N r )r r r r r s zWhiteSpaceTokenList.valuec C s dd | D S )Nc S s g | ]}|j d kr|jqS )comment)r7 content)r r r r r
s z0WhiteSpaceTokenList.comments..r )r r r r r- s z WhiteSpaceTokenList.commentsN)r$ r9 r: r= r r- r r r r r? s r? c @ s e Zd ZdZdS )UnstructuredTokenList unstructuredN)r$ r9 r: r7 r r r r rD s rD c @ s e Zd ZdZdS )PhrasephraseN)r$ r9 r: r7 r r r r rF s rF c @ s e Zd ZdZdS )WordZwordN)r$ r9 r: r7 r r r r rH s rH c @ s e Zd ZdZdS )CFWSListcfwsN)r$ r9 r: r7 r r r r rI s rI c @ s e Zd ZdZdS )AtomatomN)r$ r9 r: r7 r r r r rK s rK c @ s e Zd ZdZdZdS )Tokenr. FN)r$ r9 r: r7 Z encode_as_ewr r r r rM s rM c @ s e Zd ZdZdZdZdZdS ) EncodedWordz encoded-wordN)r$ r9 r: r7 ctecharsetlangr r r r rN s rN c @ s4 e Zd ZdZedd Zedd Zedd ZdS ) QuotedStringz
quoted-stringc C s" x | D ]}|j dkr|jS qW d S )Nzbare-quoted-string)r7 r )r r r r r rB s
zQuotedString.contentc C sB g }x2| D ]*}|j dkr(|jt| q
|j|j q
W dj|S )Nzbare-quoted-stringr )r7 appendr r r! )r resr r r r quoted_value s
zQuotedString.quoted_valuec C s" x | D ]}|j dkr|jS qW d S )Nzbare-quoted-string)r7 r )r r. r r r stripped_value s
zQuotedString.stripped_valueN)r$ r9 r: r7 r= rB rU rV r r r r rR s
rR c @ s$ e Zd ZdZdd Zedd ZdS )BareQuotedStringzbare-quoted-stringc C s t djdd | D S )Nr c s s | ]}t |V qd S )N)r )r r r r r r s z+BareQuotedString.__str__..)r r! )r r r r r" s zBareQuotedString.__str__c C s dj dd | D S )Nr c s s | ]}t |V qd S )N)r )r r r r r r s z)BareQuotedString.value..)r! )r r r r r s zBareQuotedString.valueN)r$ r9 r: r7 r" r= r r r r r rW s rW c @ s8 e Zd ZdZdd Zdd Zedd Zedd Zd
S ) CommentrA c s( dj tdg fdd D dggg S )Nr r c s g | ]} j |qS r )quote)r r )r r r rC s z#Comment.__str__.