Re-organize directory structure (#4971)

See discussion in #2491

Co-authored-by: Ivan Levkivskyi <ilevkivskyi@dropbox.com>

stdlib/email/__init__.pyi

@@ -0,0 +1,23 @@
+from email.message import Message
+from email.policy import Policy
+from typing import IO, Callable
+
+def message_from_string(s: str, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+def message_from_bytes(s: bytes, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+def message_from_file(fp: IO[str], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+def message_from_binary_file(fp: IO[bytes], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+
+# Names in __all__ with no definition:
+#   base64mime
+#   charset
+#   encoders
+#   errors
+#   feedparser
+#   generator
+#   header
+#   iterators
+#   message
+#   mime
+#   parser
+#   quoprimime
+#   utils

stdlib/email/charset.pyi

@@ -0,0 +1,28 @@
+from typing import Any, Iterator, List, Optional
+
+QP: int  # undocumented
+BASE64: int  # undocumented
+SHORTEST: int  # undocumented
+
+class Charset:
+    input_charset: str
+    header_encoding: int
+    body_encoding: int
+    output_charset: Optional[str]
+    input_codec: Optional[str]
+    output_codec: Optional[str]
+    def __init__(self, input_charset: str = ...) -> None: ...
+    def get_body_encoding(self) -> str: ...
+    def get_output_charset(self) -> Optional[str]: ...
+    def header_encode(self, string: str) -> str: ...
+    def header_encode_lines(self, string: str, maxlengths: Iterator[int]) -> List[str]: ...
+    def body_encode(self, string: str) -> str: ...
+    def __str__(self) -> str: ...
+    def __eq__(self, other: Any) -> bool: ...
+    def __ne__(self, other: Any) -> bool: ...
+
+def add_charset(
+    charset: str, header_enc: Optional[int] = ..., body_enc: Optional[int] = ..., output_charset: Optional[str] = ...
+) -> None: ...
+def add_alias(alias: str, canonical: str) -> None: ...
+def add_codec(charset: str, codecname: str) -> None: ...

stdlib/email/contentmanager.pyi

@@ -0,0 +1,11 @@
+from email.message import Message
+from typing import Any, Callable
+
+class ContentManager:
+    def __init__(self) -> None: ...
+    def get_content(self, msg: Message, *args: Any, **kw: Any) -> Any: ...
+    def set_content(self, msg: Message, obj: Any, *args: Any, **kw: Any) -> Any: ...
+    def add_get_handler(self, key: str, handler: Callable[..., Any]) -> None: ...
+    def add_set_handler(self, typekey: type, handler: Callable[..., Any]) -> None: ...
+
+raw_data_manager: ContentManager

stdlib/email/encoders.pyi

@@ -0,0 +1,6 @@
+from email.message import Message
+
+def encode_base64(msg: Message) -> None: ...
+def encode_quopri(msg: Message) -> None: ...
+def encode_7or8bit(msg: Message) -> None: ...
+def encode_noop(msg: Message) -> None: ...

stdlib/email/errors.pyi

@@ -0,0 +1,17 @@
+class MessageError(Exception): ...
+class MessageParseError(MessageError): ...
+class HeaderParseError(MessageParseError): ...
+class BoundaryError(MessageParseError): ...
+class MultipartConversionError(MessageError, TypeError): ...
+class MessageDefect(ValueError): ...
+class NoBoundaryInMultipartDefect(MessageDefect): ...
+class StartBoundaryNotFoundDefect(MessageDefect): ...
+class FirstHeaderLineIsContinuationDefect(MessageDefect): ...
+class MisplacedEnvelopeHeaderDefect(MessageDefect): ...
+class MultipartInvariantViolationDefect(MessageDefect): ...
+class InvalidBase64PaddingDefect(MessageDefect): ...
+class InvalidBase64CharactersDefect(MessageDefect): ...
+class CloseBoundaryNotFoundDefect(MessageDefect): ...
+class MissingHeaderBodySeparatorDefect(MessageDefect): ...
+
+MalformedHeaderDefect = MissingHeaderBodySeparatorDefect

stdlib/email/feedparser.pyi

@@ -0,0 +1,21 @@
+from email.message import Message
+from email.policy import Policy
+from typing import Callable, Generic, TypeVar, overload
+
+_M = TypeVar("_M", bound=Message)
+
+class FeedParser(Generic[_M]):
+    @overload
+    def __init__(self: FeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ...
+    def feed(self, data: str) -> None: ...
+    def close(self) -> _M: ...
+
+class BytesFeedParser(Generic[_M]):
+    @overload
+    def __init__(self: BytesFeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ...
+    def feed(self, data: bytes) -> None: ...
+    def close(self) -> _M: ...

stdlib/email/generator.pyi

@@ -0,0 +1,18 @@
+from email.message import Message
+from email.policy import Policy
+from typing import BinaryIO, Optional, TextIO
+
+class Generator:
+    def clone(self, fp: TextIO) -> Generator: ...
+    def write(self, s: str) -> None: ...
+    def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ...
+    def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ...
+
+class BytesGenerator:
+    def clone(self, fp: BinaryIO) -> BytesGenerator: ...
+    def write(self, s: str) -> None: ...
+    def __init__(self, outfp: BinaryIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ...
+    def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ...
+
+class DecodedGenerator(Generator):
+    def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, fmt: Optional[str] = ...) -> None: ...

stdlib/email/header.pyi

@@ -0,0 +1,26 @@
+from email.charset import Charset
+from typing import Any, List, Optional, Tuple, Union
+
+class Header:
+    def __init__(
+        self,
+        s: Union[bytes, str, None] = ...,
+        charset: Union[Charset, str, None] = ...,
+        maxlinelen: Optional[int] = ...,
+        header_name: Optional[str] = ...,
+        continuation_ws: str = ...,
+        errors: str = ...,
+    ) -> None: ...
+    def append(self, s: Union[bytes, str], charset: Union[Charset, str, None] = ..., errors: str = ...) -> None: ...
+    def encode(self, splitchars: str = ..., maxlinelen: Optional[int] = ..., linesep: str = ...) -> str: ...
+    def __str__(self) -> str: ...
+    def __eq__(self, other: Any) -> bool: ...
+    def __ne__(self, other: Any) -> bool: ...
+
+def decode_header(header: Union[Header, str]) -> List[Tuple[bytes, Optional[str]]]: ...
+def make_header(
+    decoded_seq: List[Tuple[bytes, Optional[str]]],
+    maxlinelen: Optional[int] = ...,
+    header_name: Optional[str] = ...,
+    continuation_ws: str = ...,
+) -> Header: ...

stdlib/email/headerregistry.pyi

@@ -0,0 +1,90 @@
+from datetime import datetime as _datetime
+from email.errors import MessageDefect
+from email.policy import Policy
+from typing import Any, Dict, Mapping, Optional, Tuple, Union
+
+class BaseHeader(str):
+    @property
+    def name(self) -> str: ...
+    @property
+    def defects(self) -> Tuple[MessageDefect, ...]: ...
+    @property
+    def max_count(self) -> Optional[int]: ...
+    def __new__(cls, name: str, value: Any) -> BaseHeader: ...
+    def init(self, *args: Any, **kw: Any) -> None: ...
+    def fold(self, *, policy: Policy) -> str: ...
+
+class UnstructuredHeader:
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class UniqueUnstructuredHeader(UnstructuredHeader): ...
+
+class DateHeader:
+    datetime: _datetime
+    @classmethod
+    def parse(cls, string: Union[str, _datetime], kwds: Dict[str, Any]) -> None: ...
+
+class UniqueDateHeader(DateHeader): ...
+
+class AddressHeader:
+    groups: Tuple[Group, ...]
+    addresses: Tuple[Address, ...]
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class UniqueAddressHeader(AddressHeader): ...
+
+class SingleAddressHeader(AddressHeader):
+    @property
+    def address(self) -> Address: ...
+
+class UniqueSingleAddressHeader(SingleAddressHeader): ...
+
+class MIMEVersionHeader:
+    version: Optional[str]
+    major: Optional[int]
+    minor: Optional[int]
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class ParameterizedMIMEHeader:
+    params: Mapping[str, Any]
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class ContentTypeHeader(ParameterizedMIMEHeader):
+    content_type: str
+    maintype: str
+    subtype: str
+
+class ContentDispositionHeader(ParameterizedMIMEHeader):
+    content_disposition: str
+
+class ContentTransferEncodingHeader:
+    cte: str
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class HeaderRegistry:
+    def __init__(self, base_class: BaseHeader = ..., default_class: BaseHeader = ..., use_default_map: bool = ...) -> None: ...
+    def map_to_type(self, name: str, cls: BaseHeader) -> None: ...
+    def __getitem__(self, name: str) -> BaseHeader: ...
+    def __call__(self, name: str, value: Any) -> BaseHeader: ...
+
+class Address:
+    display_name: str
+    username: str
+    domain: str
+    @property
+    def addr_spec(self) -> str: ...
+    def __init__(
+        self, display_name: str = ..., username: Optional[str] = ..., domain: Optional[str] = ..., addr_spec: Optional[str] = ...
+    ) -> None: ...
+    def __str__(self) -> str: ...
+
+class Group:
+    display_name: Optional[str]
+    addresses: Tuple[Address, ...]
+    def __init__(self, display_name: Optional[str] = ..., addresses: Optional[Tuple[Address, ...]] = ...) -> None: ...
+    def __str__(self) -> str: ...

stdlib/email/iterators.pyi

@@ -0,0 +1,5 @@
+from email.message import Message
+from typing import Iterator, Optional
+
+def body_line_iterator(msg: Message, decode: bool = ...) -> Iterator[str]: ...
+def typed_subpart_iterator(msg: Message, maintype: str = ..., subtype: Optional[str] = ...) -> Iterator[str]: ...

stdlib/email/message.pyi

@@ -0,0 +1,87 @@
+from email.charset import Charset
+from email.contentmanager import ContentManager
+from email.errors import MessageDefect
+from email.policy import Policy
+from typing import Any, Generator, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union
+
+_T = TypeVar("_T")
+
+_PayloadType = Union[List[Message], str, bytes]
+_CharsetType = Union[Charset, str, None]
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
+_HeaderType = Any
+
+class Message:
+    preamble: Optional[str]
+    epilogue: Optional[str]
+    defects: List[MessageDefect]
+    def __str__(self) -> str: ...
+    def is_multipart(self) -> bool: ...
+    def set_unixfrom(self, unixfrom: str) -> None: ...
+    def get_unixfrom(self) -> Optional[str]: ...
+    def attach(self, payload: Message) -> None: ...
+    def get_payload(self, i: int = ..., decode: bool = ...) -> Any: ...  # returns Optional[_PayloadType]
+    def set_payload(self, payload: _PayloadType, charset: _CharsetType = ...) -> None: ...
+    def set_charset(self, charset: _CharsetType) -> None: ...
+    def get_charset(self) -> _CharsetType: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, name: str) -> bool: ...
+    def __getitem__(self, name: str) -> _HeaderType: ...
+    def __setitem__(self, name: str, val: _HeaderType) -> None: ...
+    def __delitem__(self, name: str) -> None: ...
+    def keys(self) -> List[str]: ...
+    def values(self) -> List[_HeaderType]: ...
+    def items(self) -> List[Tuple[str, _HeaderType]]: ...
+    def get(self, name: str, failobj: _T = ...) -> Union[_HeaderType, _T]: ...
+    def get_all(self, name: str, failobj: _T = ...) -> Union[List[_HeaderType], _T]: ...
+    def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ...
+    def replace_header(self, _name: str, _value: _HeaderType) -> None: ...
+    def get_content_type(self) -> str: ...
+    def get_content_maintype(self) -> str: ...
+    def get_content_subtype(self) -> str: ...
+    def get_default_type(self) -> str: ...
+    def set_default_type(self, ctype: str) -> None: ...
+    def get_params(self, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[List[Tuple[str, str]], _T]: ...
+    def get_param(self, param: str, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[_T, _ParamType]: ...
+    def del_param(self, param: str, header: str = ..., requote: bool = ...) -> None: ...
+    def set_type(self, type: str, header: str = ..., requote: bool = ...) -> None: ...
+    def get_filename(self, failobj: _T = ...) -> Union[_T, str]: ...
+    def get_boundary(self, failobj: _T = ...) -> Union[_T, str]: ...
+    def set_boundary(self, boundary: str) -> None: ...
+    def get_content_charset(self, failobj: _T = ...) -> Union[_T, str]: ...
+    def get_charsets(self, failobj: _T = ...) -> Union[_T, List[str]]: ...
+    def walk(self) -> Generator[Message, None, None]: ...
+    def get_content_disposition(self) -> Optional[str]: ...
+    def as_string(self, unixfrom: bool = ..., maxheaderlen: int = ..., policy: Optional[Policy] = ...) -> str: ...
+    def as_bytes(self, unixfrom: bool = ..., policy: Optional[Policy] = ...) -> bytes: ...
+    def __bytes__(self) -> bytes: ...
+    def set_param(
+        self,
+        param: str,
+        value: str,
+        header: str = ...,
+        requote: bool = ...,
+        charset: str = ...,
+        language: str = ...,
+        replace: bool = ...,
+    ) -> None: ...
+    def __init__(self, policy: Policy = ...) -> None: ...
+
+class MIMEPart(Message):
+    def get_body(self, preferencelist: Sequence[str] = ...) -> Optional[Message]: ...
+    def iter_attachments(self) -> Iterator[Message]: ...
+    def iter_parts(self) -> Iterator[Message]: ...
+    def get_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> Any: ...
+    def set_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def make_related(self, boundary: Optional[str] = ...) -> None: ...
+    def make_alternative(self, boundary: Optional[str] = ...) -> None: ...
+    def make_mixed(self, boundary: Optional[str] = ...) -> None: ...
+    def add_related(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def add_alternative(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def add_attachment(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def clear(self) -> None: ...
+    def clear_content(self) -> None: ...
+    def is_attachment(self) -> bool: ...
+
+class EmailMessage(MIMEPart): ...

stdlib/email/mime/application.pyi

@@ -0,0 +1,16 @@
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Callable, Optional, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEApplication(MIMENonMultipart):
+    def __init__(
+        self,
+        _data: Union[str, bytes],
+        _subtype: str = ...,
+        _encoder: Callable[[MIMEApplication], None] = ...,
+        *,
+        policy: Optional[Policy] = ...,
+        **_params: _ParamsType,
+    ) -> None: ...

stdlib/email/mime/audio.pyi

@@ -0,0 +1,16 @@
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Callable, Optional, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEAudio(MIMENonMultipart):
+    def __init__(
+        self,
+        _audiodata: Union[str, bytes],
+        _subtype: Optional[str] = ...,
+        _encoder: Callable[[MIMEAudio], None] = ...,
+        *,
+        policy: Optional[Policy] = ...,
+        **_params: _ParamsType,
+    ) -> None: ...

stdlib/email/mime/base.pyi

@@ -0,0 +1,8 @@
+import email.message
+from email.policy import Policy
+from typing import Optional, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEBase(email.message.Message):
+    def __init__(self, _maintype: str, _subtype: str, *, policy: Optional[Policy] = ..., **_params: _ParamsType) -> None: ...

stdlib/email/mime/image.pyi

@@ -0,0 +1,16 @@
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Callable, Optional, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEImage(MIMENonMultipart):
+    def __init__(
+        self,
+        _imagedata: Union[str, bytes],
+        _subtype: Optional[str] = ...,
+        _encoder: Callable[[MIMEImage], None] = ...,
+        *,
+        policy: Optional[Policy] = ...,
+        **_params: _ParamsType,
+    ) -> None: ...

stdlib/email/mime/message.pyi

@@ -0,0 +1,7 @@
+from email.message import Message
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Optional
+
+class MIMEMessage(MIMENonMultipart):
+    def __init__(self, _msg: Message, _subtype: str = ..., *, policy: Optional[Policy] = ...) -> None: ...

stdlib/email/mime/multipart.pyi

@@ -0,0 +1,17 @@
+from email.message import Message
+from email.mime.base import MIMEBase
+from email.policy import Policy
+from typing import Optional, Sequence, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEMultipart(MIMEBase):
+    def __init__(
+        self,
+        _subtype: str = ...,
+        boundary: Optional[str] = ...,
+        _subparts: Optional[Sequence[Message]] = ...,
+        *,
+        policy: Optional[Policy] = ...,
+        **_params: _ParamsType,
+    ) -> None: ...

stdlib/email/mime/nonmultipart.pyi

@@ -0,0 +1,3 @@
+from email.mime.base import MIMEBase
+
+class MIMENonMultipart(MIMEBase): ...

stdlib/email/mime/text.pyi

@@ -0,0 +1,8 @@
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Optional
+
+class MIMEText(MIMENonMultipart):
+    def __init__(
+        self, _text: str, _subtype: str = ..., _charset: Optional[str] = ..., *, policy: Optional[Policy] = ...
+    ) -> None: ...

stdlib/email/parser.pyi

@@ -0,0 +1,27 @@
+import email.feedparser
+from email.message import Message
+from email.policy import Policy
+from typing import BinaryIO, Callable, TextIO
+
+FeedParser = email.feedparser.FeedParser
+BytesFeedParser = email.feedparser.BytesFeedParser
+
+class Parser:
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
+    def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
+
+class HeaderParser(Parser):
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
+    def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
+
+class BytesHeaderParser(BytesParser):
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
+    def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ...
+
+class BytesParser:
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
+    def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ...

stdlib/email/policy.pyi

@@ -0,0 +1,54 @@
+from abc import abstractmethod
+from email.contentmanager import ContentManager
+from email.errors import MessageDefect
+from email.header import Header
+from email.message import Message
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+class Policy:
+    max_line_length: Optional[int]
+    linesep: str
+    cte_type: str
+    raise_on_defect: bool
+    mange_from: bool
+    def __init__(self, **kw: Any) -> None: ...
+    def clone(self, **kw: Any) -> Policy: ...
+    def handle_defect(self, obj: Message, defect: MessageDefect) -> None: ...
+    def register_defect(self, obj: Message, defect: MessageDefect) -> None: ...
+    def header_max_count(self, name: str) -> Optional[int]: ...
+    @abstractmethod
+    def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
+    @abstractmethod
+    def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
+    @abstractmethod
+    def header_fetch_parse(self, name: str, value: str) -> str: ...
+    @abstractmethod
+    def fold(self, name: str, value: str) -> str: ...
+    @abstractmethod
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+class Compat32(Policy):
+    def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
+    def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
+    def header_fetch_parse(self, name: str, value: str) -> Union[str, Header]: ...  # type: ignore
+    def fold(self, name: str, value: str) -> str: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+compat32: Compat32
+
+class EmailPolicy(Policy):
+    utf8: bool
+    refold_source: str
+    header_factory: Callable[[str, str], str]
+    content_manager: ContentManager
+    def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
+    def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
+    def header_fetch_parse(self, name: str, value: str) -> str: ...
+    def fold(self, name: str, value: str) -> str: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+default: EmailPolicy
+SMTP: EmailPolicy
+SMTPUTF8: EmailPolicy
+HTTP: EmailPolicy
+strict: EmailPolicy

stdlib/email/utils.pyi

@@ -0,0 +1,40 @@
+import datetime
+import sys
+from email.charset import Charset
+from typing import List, Optional, Tuple, Union, overload
+
+_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
+_PDTZ = Tuple[int, int, int, int, int, int, int, int, int, Optional[int]]
+
+def quote(str: str) -> str: ...
+def unquote(str: str) -> str: ...
+def parseaddr(address: Optional[str]) -> Tuple[str, str]: ...
+def formataddr(pair: Tuple[Optional[str], str], charset: Union[str, Charset] = ...) -> str: ...
+def getaddresses(fieldvalues: List[str]) -> List[Tuple[str, str]]: ...
+@overload
+def parsedate(date: None) -> None: ...
+@overload
+def parsedate(date: str) -> Optional[Tuple[int, int, int, int, int, int, int, int, int]]: ...
+@overload
+def parsedate_tz(date: None) -> None: ...
+@overload
+def parsedate_tz(date: str) -> Optional[_PDTZ]: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def parsedate_to_datetime(date: None) -> None: ...
+    @overload
+    def parsedate_to_datetime(date: str) -> datetime.datetime: ...
+
+else:
+    def parsedate_to_datetime(date: str) -> datetime.datetime: ...
+
+def mktime_tz(tuple: _PDTZ) -> int: ...
+def formatdate(timeval: Optional[float] = ..., localtime: bool = ..., usegmt: bool = ...) -> str: ...
+def format_datetime(dt: datetime.datetime, usegmt: bool = ...) -> str: ...
+def localtime(dt: Optional[datetime.datetime] = ...) -> datetime.datetime: ...
+def make_msgid(idstring: Optional[str] = ..., domain: Optional[str] = ...) -> str: ...
+def decode_rfc2231(s: str) -> Tuple[Optional[str], Optional[str], str]: ...
+def encode_rfc2231(s: str, charset: Optional[str] = ..., language: Optional[str] = ...) -> str: ...
+def collapse_rfc2231_value(value: _ParamType, errors: str = ..., fallback_charset: str = ...) -> str: ...
+def decode_params(params: List[Tuple[str, str]]) -> List[Tuple[str, _ParamType]]: ...