token_type = None

syntactic_break = True

ew_combine_allowed = True

def __init__(self, *args, **kw):

super().__init__(*args, **kw)

self.defects = []

def __str__(self):

return ''.join(str(x) for x in self)

def __repr__(self):

return '{}({})'.format(self.__class__.__name__,

super().__repr__())

@property

def value(self):

return ''.join(x.value for x in self if x.value)

@property

def all_defects(self):

return sum((x.all_defects for x in self), self.defects)

def startswith_fws(self):

return self[0].startswith_fws()

@property

def as_ew_allowed(self):

"""True if all top level tokens of this part may be RFC2047 encoded."""

return all(part.as_ew_allowed for part in self)

@property

def comments(self):

comments = []

for token in self:

comments.extend(token.comments)

return comments

def fold(self, *, policy):

return _refold_parse_tree(self, policy=policy)

def pprint(self, indent=''):

print(self.ppstr(indent=indent))

def ppstr(self, indent=''):

return '\n'.join(self._pp(indent=indent))

def _pp(self, indent=''):

yield '{}{}/{}('.format(

indent,

self.__class__.__name__,

self.token_type)

for token in self:

if not hasattr(token, '_pp'):

yield (indent + ' !! invalid element in token '

'list: {!r}'.format(token))

else:

yield from token._pp(indent+' ')

if self.defects:

extra = ' Defects: {}'.format(self.defects)

else:

extra = ''

@property

def value(self):

return ' '

@property

def comments(self):

token_type = 'encoded-word'

cte = None

charset = None

token_type = 'quoted-string'

@property

def content(self):

for x in self:

if x.token_type == 'bare-quoted-string':

return x.value

@property

def quoted_value(self):

res = []

for x in self:

if x.token_type == 'bare-quoted-string':

res.append(str(x))

else:

res.append(x.value)

return ''.join(res)

@property

def stripped_value(self):

for token in self:

if token.token_type == 'bare-quoted-string':

token_type = 'bare-quoted-string'

def __str__(self):

return quote_string(''.join(str(x) for x in self))

@property

def value(self):

token_type = 'comment'

def __str__(self):

return ''.join(sum([

["("],

[self.quote(x) for x in self],

[")"],

], []))

def quote(self, value):

if value.token_type == 'comment':

return str(value)

return str(value).replace('\\', '\\\\').replace(

'(', r'\(').replace(

')', r'\)')

@property

def content(self):

return ''.join(str(x) for x in self)

@property

def comments(self):

token_type = 'address-list'

@property

def addresses(self):

return [x for x in self if x.token_type=='address']

@property

def mailboxes(self):

return sum((x.mailboxes

for x in self if x.token_type=='address'), [])

@property

def all_mailboxes(self):

return sum((x.all_mailboxes

token_type = 'address'

@property

def display_name(self):

if self[0].token_type == 'group':

return self[0].display_name

@property

def mailboxes(self):

if self[0].token_type == 'mailbox':

return [self[0]]

elif self[0].token_type == 'invalid-mailbox':

return []

return self[0].mailboxes

@property

def all_mailboxes(self):

if self[0].token_type == 'mailbox':

return [self[0]]

elif self[0].token_type == 'invalid-mailbox':

return [self[0]]

token_type = 'mailbox-list'

@property

def mailboxes(self):

return [x for x in self if x.token_type=='mailbox']

@property

def all_mailboxes(self):

return [x for x in self

token_type = 'group-list'

@property

def mailboxes(self):

if not self or self[0].token_type != 'mailbox-list':

return []

return self[0].mailboxes

@property

def all_mailboxes(self):

if not self or self[0].token_type != 'mailbox-list':

return []

token_type = "group"

@property

def mailboxes(self):

if self[2].token_type != 'group-list':

return []

return self[2].mailboxes

@property

def all_mailboxes(self):

if self[2].token_type != 'group-list':

return []

return self[2].all_mailboxes

@property

def display_name(self):

token_type = 'name-addr'

@property

def display_name(self):

if len(self) == 1:

return None

return self[0].display_name

@property

def local_part(self):

return self[-1].local_part

@property

def domain(self):

return self[-1].domain

@property

def route(self):

return self[-1].route

@property

def addr_spec(self):

token_type = 'angle-addr'

@property

def local_part(self):

for x in self:

if x.token_type == 'addr-spec':

return x.local_part

@property

def domain(self):

for x in self:

if x.token_type == 'addr-spec':

return x.domain

@property

def route(self):

for x in self:

if x.token_type == 'obs-route':

return x.domains

@property

def addr_spec(self):

for x in self:

if x.token_type == 'addr-spec':

if x.local_part:

return x.addr_spec

else:

return quote_string(x.local_part) + x.addr_spec

else:

token_type = 'obs-route'

@property

def domains(self):

token_type = 'mailbox'

@property

def display_name(self):

if self[0].token_type == 'name-addr':

return self[0].display_name

@property

def local_part(self):

return self[0].local_part

@property

def domain(self):

return self[0].domain

@property

def route(self):

if self[0].token_type == 'name-addr':

return self[0].route

@property

def addr_spec(self):

token_type = 'invalid-mailbox'

@property

def display_name(self):

return None

token_type = 'domain'

as_ew_allowed = False

@property

def domain(self):

token_type = 'addr-spec'

as_ew_allowed = False

@property

def local_part(self):

return self[0].local_part

@property

def domain(self):

if len(self) < 3:

return None

return self[-1].domain

@property

def value(self):

if len(self) < 3:

return self[0].value

return self[0].value.rstrip()+self[1].value+self[2].value.lstrip()

@property

def addr_spec(self):

nameset = set(self.local_part)

if len(nameset) > len(nameset-DOT_ATOM_ENDS):

lp = quote_string(self.local_part)

else:

lp = self.local_part

if self.domain is not None:

return lp + '@' + self.domain

token_type = 'display-name'

ew_combine_allowed = False

@property

def display_name(self):

res = TokenList(self)

if len(res) == 0:

return res.value

if res[0].token_type == 'cfws':

res.pop(0)

else:

if res[0][0].token_type == 'cfws':

res[0] = TokenList(res[0][1:])

if res[-1].token_type == 'cfws':

res.pop()

else:

if res[-1][-1].token_type == 'cfws':

res[-1] = TokenList(res[-1][:-1])

return res.value

@property

def value(self):

quote = False

if self.defects:

quote = True

else:

for x in self:

if x.token_type == 'quoted-string':

quote = True

if len(self) != 0 and quote:

pre = post = ''

if self[0].token_type=='cfws' or self[0][0].token_type=='cfws':

pre = ' '

if self[-1].token_type=='cfws' or self[-1][-1].token_type=='cfws':

post = ' '

return pre+quote_string(self.display_name)+post

else:

token_type = 'local-part'

as_ew_allowed = False

@property

def value(self):

if self[0].token_type == "quoted-string":

return self[0].quoted_value

else:

return self[0].value

@property

def local_part(self):

# Strip whitespace from front, back, and around dots.

res = [DOT]

last = DOT

last_is_tl = False

for tok in self[0] + [DOT]:

if tok.token_type == 'cfws':

continue

if (last_is_tl and tok.token_type == 'dot' and

last[-1].token_type == 'cfws'):

res[-1] = TokenList(last[:-1])

is_tl = isinstance(tok, TokenList)

if (is_tl and last.token_type == 'dot' and

tok[0].token_type == 'cfws'):

res.append(TokenList(tok[1:]))

else:

res.append(tok)

last = res[-1]

last_is_tl = is_tl

res = TokenList(res[1:-1])

token_type = 'domain-literal'

as_ew_allowed = False

@property

def domain(self):

return ''.join(super().value.split())

@property

def ip(self):

for x in self:

if x.token_type == 'ptext':

token_type = 'mime-version'

major = None

token_type = 'parameter'

sectioned = False

extended = False

charset = 'us-ascii'

@property

def section_number(self):

# Because the first token, the attribute (name) eats CFWS, the second

# token is always the section if there is one.

return self[1].number if self.sectioned else 0

@property

def param_value(self):

# This is part of the "handle quoted extended parameters" hack.

for token in self:

if token.token_type == 'value':

return token.stripped_value

if token.token_type == 'quoted-string':

for token in token:

if token.token_type == 'bare-quoted-string':

for token in token:

if token.token_type == 'value':

return token.stripped_value

token_type = 'attribute'

@property

def stripped_value(self):

for token in self:

if token.token_type.endswith('attrtext'):

token_type = 'value'

@property

def stripped_value(self):

token = self[0]

if token.token_type == 'cfws':

token = self[1]

if token.token_type.endswith(

('quoted-string', 'attribute', 'extended-attribute')):

return token.stripped_value

token_type = 'mime-parameters'

syntactic_break = False

@property

def params(self):

# The RFC specifically states that the ordering of parameters is not

# guaranteed and may be reordered by the transport layer. So we have

# to assume the RFC 2231 pieces can come in any order. However, we

# output them in the order that we first see a given name, which gives

# us a stable __str__.

params = {} # Using order preserving dict from Python 3.7+

for token in self:

if not token.token_type.endswith('parameter'):

continue

if token[0].token_type != 'attribute':

continue

name = token[0].value.strip()

if name not in params:

params[name] = []

params[name].append((token.section_number, token))

for name, parts in params.items():

parts = sorted(parts, key=itemgetter(0))

first_param = parts[0][1]

charset = first_param.charset

# Our arbitrary error recovery is to ignore duplicate parameters,

# to use appearance order if there are duplicate rfc 2231 parts,

# and to ignore gaps. This mimics the error recovery of get_param.

if not first_param.extended and len(parts) > 1:

if parts[1][0] == 0:

parts[1][1].defects.append(errors.InvalidHeaderDefect(

'duplicate parameter name; duplicate(s) ignored'))

parts = parts[:1]

# Else assume the *0* was missing...note that this is different

# from get_param, but we registered a defect for this earlier.

value_parts = []

i = 0

for section_number, param in parts:

if section_number != i:

# We could get fancier here and look for a complete

# duplicate extended parameter and ignore the second one

# seen. But we're not doing that. The old code didn't.

if not param.extended:

param.defects.append(errors.InvalidHeaderDefect(

'duplicate parameter name; duplicate ignored'))

continue

else:

param.defects.append(errors.InvalidHeaderDefect(

"inconsistent RFC2231 parameter numbering"))

i += 1

value = param.param_value

if param.extended:

try:

value = urllib.parse.unquote_to_bytes(value)

except UnicodeEncodeError:

# source had surrogate escaped bytes. What we do now

# is a bit of an open question. I'm not sure this is

# the best choice, but it is what the old algorithm did

value = urllib.parse.unquote(value, encoding='latin-1')

else:

try:

value = value.decode(charset, 'surrogateescape')

except (LookupError, UnicodeEncodeError):

# XXX: there should really be a custom defect for

# unknown character set to make it easy to find,

# because otherwise unknown charset is a silent

# failure.

value = value.decode('us-ascii', 'surrogateescape')

if utils._has_surrogates(value):

param.defects.append(errors.UndecodableBytesDefect())

value_parts.append(value)

value = ''.join(value_parts)

yield name, value

def __str__(self):

params = []

for name, value in self.params:

if value:

params.append('{}={}'.format(name, quote_string(value)))

else:

params.append(name)

params = '; '.join(params)

# Set this false so that the value doesn't wind up on a new line even

# if it and the parameters would fit there but not on the first line.

syntactic_break = False

@property

def params(self):

for token in reversed(self):

if token.token_type == 'mime-parameters':

return token.params

token_type = 'content-type'

as_ew_allowed = False

maintype = 'text'

token_type = 'msg-id'

as_ew_allowed = False

def fold(self, policy):

# message-id tokens may not be folded.

as_ew_allowed = True

ew_combine_allowed = True

syntactic_break = True

def __new__(cls, value, token_type):

self = super().__new__(cls, value)

self.token_type = token_type

self.defects = []

return self

def __repr__(self):

return "{}({})".format(self.__class__.__name__, super().__repr__())

def pprint(self):

print(self.__class__.__name__ + '/' + self.token_type)

@property

def all_defects(self):

return list(self.defects)

def _pp(self, indent=''):

return ["{}{}/{}({}){}".format(

indent,

self.__class__.__name__,

self.token_type,

super().__repr__(),

'' if not self.defects else ' {}'.format(self.defects),

)]

def pop_trailing_ws(self):

# This terminates the recursion.

return None

@property

def comments(self):

return []

def __getnewargs__(self):

@property

def value(self):

return ' '

def startswith_fws(self):

@property

def value(self):

return self

def startswith_fws(self):

@property

def value(self):

return ''

def __str__(self):

"""If input token contains ASCII non-printables, register a defect."""

non_printables = _non_printable_finder(xtext)

if non_printables:

xtext.defects.append(errors.NonPrintableDefect(non_printables))

if utils._has_surrogates(xtext):

xtext.defects.append(errors.UndecodableBytesDefect(

"""Scan printables/quoted-pairs until endchars and return unquoted ptext.