golden hour

/lib64/python3.6/email

File/Folder	Size	Actions
__init__.py	1.72 KB
__pycache__	-
_encoded_words.py	8.32 KB
_header_value_parser.py	97.51 KB
_parseaddr.py	17.19 KB
_policybase.py	15.07 KB
architecture.rst	9.34 KB
base64mime.py	3.47 KB
charset.py	16.75 KB
contentmanager.py	10.42 KB
encoders.py	1.74 KB
errors.py	3.71 KB
feedparser.py	22.24 KB
generator.py	20.71 KB
header.py	23.54 KB
headerregistry.py	19.75 KB
iterators.py	2.08 KB
message.py	45.62 KB
mime	-
parser.py	4.92 KB
policy.py	10.13 KB
quoprimime.py	9.63 KB
utils.py	17.28 KB

Edit: errors.py

# Copyright (C) 2001-2006 Python Software Foundation
# Author: Barry Warsaw
# Contact: email-sig@python.org

"""email package exception classes."""

class MessageError(Exception):
    """Base class for errors in the email package."""

class MessageParseError(MessageError):
    """Base class for message parsing errors."""

class HeaderParseError(MessageParseError):
    """Error while parsing headers."""

class BoundaryError(MessageParseError):
    """Couldn't find terminating boundary."""

class MultipartConversionError(MessageError, TypeError):
    """Conversion to a multipart is prohibited."""

class CharsetError(MessageError):
    """An illegal charset was given."""

# These are parsing defects which the parser was able to work around.
class MessageDefect(ValueError):
    """Base class for a message defect."""

def __init__(self, line=None):
        if line is not None:
            super().__init__(line)
        self.line = line

class NoBoundaryInMultipartDefect(MessageDefect):
    """A message claimed to be a multipart but had no boundary parameter."""

class StartBoundaryNotFoundDefect(MessageDefect):
    """The claimed start boundary was never found."""

class CloseBoundaryNotFoundDefect(MessageDefect):
    """A start boundary was found, but not the corresponding close boundary."""

class FirstHeaderLineIsContinuationDefect(MessageDefect):
    """A message had a continuation line as its first header line."""

class MisplacedEnvelopeHeaderDefect(MessageDefect):
    """A 'Unix-from' header was found in the middle of a header block."""

class MissingHeaderBodySeparatorDefect(MessageDefect):
    """Found line with no leading whitespace and no colon before blank line."""
# XXX: backward compatibility, just in case (it was never emitted).
MalformedHeaderDefect = MissingHeaderBodySeparatorDefect

class MultipartInvariantViolationDefect(MessageDefect):
    """A message claimed to be a multipart but no subparts were found."""

class InvalidMultipartContentTransferEncodingDefect(MessageDefect):
    """An invalid content transfer encoding was set on the multipart itself."""

class UndecodableBytesDefect(MessageDefect):
    """Header contained bytes that could not be decoded"""

class InvalidBase64PaddingDefect(MessageDefect):
    """base64 encoded sequence had an incorrect length"""

class InvalidBase64CharactersDefect(MessageDefect):
    """base64 encoded sequence had characters not in base64 alphabet"""

class InvalidBase64LengthDefect(MessageDefect):
    """base64 encoded sequence had invalid length (1 mod 4)"""

# These errors are specific to header parsing.

class HeaderDefect(MessageDefect):
    """Base class for a header defect."""

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

class InvalidHeaderDefect(HeaderDefect):
    """Header is not valid, message gives details."""

class HeaderMissingRequiredValue(HeaderDefect):
    """A header that must have a value had none"""

class NonPrintableDefect(HeaderDefect):
    """ASCII characters outside the ascii-printable range found"""

def __init__(self, non_printables):
        super().__init__(non_printables)
        self.non_printables = non_printables

def __str__(self):
        return ("the following ASCII non-printables found in header: "
            "{}".format(self.non_printables))

class ObsoleteHeaderDefect(HeaderDefect):
    """Header uses syntax declared obsolete by RFC 5322"""

class NonASCIILocalPartDefect(HeaderDefect):
    """local_part contains non-ASCII characters"""
    # This defect only occurs during unicode parsing, not when
    # parsing messages decoded from binary.

# Errors raised during generation.

class HeaderWriteError(MessageError):
    """Error raised when a header cannot be written due to being malformed."""