mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/typeshed/stdlib/email/_policybase.pyi

@@ -0,0 +1,51 @@
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable
+from email.errors import MessageDefect
+from email.header import Header
+from email.message import Message
+from typing import Any
+from typing_extensions import Self
+
+class _PolicyBase:
+    def __add__(self, other: Any) -> Self: ...
+    def clone(self, **kw: Any) -> Self: ...
+
+class Policy(_PolicyBase, metaclass=ABCMeta):
+    max_line_length: int | None
+    linesep: str
+    cte_type: str
+    raise_on_defect: bool
+    mangle_from_: bool
+    message_factory: Callable[[Policy], Message] | None
+    def __init__(
+        self,
+        *,
+        max_line_length: int | None = 78,
+        linesep: str = "\n",
+        cte_type: str = "8bit",
+        raise_on_defect: bool = False,
+        mangle_from_: bool = False,
+        message_factory: Callable[[Policy], Message] | None = None,
+    ) -> None: ...
+    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) -> int | None: ...
+    @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) -> str | Header: ...  # type: ignore[override]
+    def fold(self, name: str, value: str) -> str: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+compat32: Compat32

mypy/typeshed/stdlib/email/base64mime.pyi

@@ -0,0 +1,13 @@
+__all__ = ["body_decode", "body_encode", "decode", "decodestring", "header_encode", "header_length"]
+
+from _typeshed import ReadableBuffer
+
+def header_length(bytearray: str | bytes | bytearray) -> int: ...
+def header_encode(header_bytes: str | ReadableBuffer, charset: str = "iso-8859-1") -> str: ...
+
+# First argument should be a buffer that supports slicing and len().
+def body_encode(s: bytes | bytearray, maxlinelen: int = 76, eol: str = "\n") -> str: ...
+def decode(string: str | ReadableBuffer) -> bytes: ...
+
+body_decode = decode
+decodestring = decode

mypy/typeshed/stdlib/email/charset.pyi

@@ -0,0 +1,34 @@
+from collections.abc import Callable, Iterator
+from email.message import Message
+from typing import overload
+
+__all__ = ["Charset", "add_alias", "add_charset", "add_codec"]
+
+QP: int  # undocumented
+BASE64: int  # undocumented
+SHORTEST: int  # undocumented
+
+class Charset:
+    input_charset: str
+    header_encoding: int
+    body_encoding: int
+    output_charset: str | None
+    input_codec: str | None
+    output_codec: str | None
+    def __init__(self, input_charset: str = "us-ascii") -> None: ...
+    def get_body_encoding(self) -> str | Callable[[Message], None]: ...
+    def get_output_charset(self) -> str | None: ...
+    def header_encode(self, string: str) -> str: ...
+    def header_encode_lines(self, string: str, maxlengths: Iterator[int]) -> list[str | None]: ...
+    @overload
+    def body_encode(self, string: None) -> None: ...
+    @overload
+    def body_encode(self, string: str | bytes) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, __value: object) -> bool: ...
+
+def add_charset(
+    charset: str, header_enc: int | None = None, body_enc: int | None = None, output_charset: str | None = None
+) -> None: ...
+def add_alias(alias: str, canonical: str) -> None: ...
+def add_codec(charset: str, codecname: str) -> None: ...

mypy/typeshed/stdlib/email/contentmanager.pyi

@@ -0,0 +1,11 @@
+from collections.abc import Callable
+from email.message import Message
+from typing import Any
+
+class ContentManager:
+    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

mypy/typeshed/stdlib/email/encoders.pyi

@@ -0,0 +1,8 @@
+from email.message import Message
+
+__all__ = ["encode_7or8bit", "encode_base64", "encode_noop", "encode_quopri"]
+
+def encode_base64(msg: Message) -> None: ...
+def encode_quopri(msg: Message) -> None: ...
+def encode_7or8bit(msg: Message) -> None: ...
+def encode_noop(msg: Message) -> None: ...

mypy/typeshed/stdlib/email/errors.pyi

@@ -0,0 +1,39 @@
+import sys
+
+class MessageError(Exception): ...
+class MessageParseError(MessageError): ...
+class HeaderParseError(MessageParseError): ...
+class BoundaryError(MessageParseError): ...
+class MultipartConversionError(MessageError, TypeError): ...
+class CharsetError(MessageError): ...
+
+class MessageDefect(ValueError):
+    def __init__(self, line: str | None = None) -> None: ...
+
+class NoBoundaryInMultipartDefect(MessageDefect): ...
+class StartBoundaryNotFoundDefect(MessageDefect): ...
+class FirstHeaderLineIsContinuationDefect(MessageDefect): ...
+class MisplacedEnvelopeHeaderDefect(MessageDefect): ...
+class MultipartInvariantViolationDefect(MessageDefect): ...
+class InvalidMultipartContentTransferEncodingDefect(MessageDefect): ...
+class UndecodableBytesDefect(MessageDefect): ...
+class InvalidBase64PaddingDefect(MessageDefect): ...
+class InvalidBase64CharactersDefect(MessageDefect): ...
+class InvalidBase64LengthDefect(MessageDefect): ...
+class CloseBoundaryNotFoundDefect(MessageDefect): ...
+class MissingHeaderBodySeparatorDefect(MessageDefect): ...
+
+MalformedHeaderDefect = MissingHeaderBodySeparatorDefect
+
+class HeaderDefect(MessageDefect): ...
+class InvalidHeaderDefect(HeaderDefect): ...
+class HeaderMissingRequiredValue(HeaderDefect): ...
+
+class NonPrintableDefect(HeaderDefect):
+    def __init__(self, non_printables: str | None) -> None: ...
+
+class ObsoleteHeaderDefect(HeaderDefect): ...
+class NonASCIILocalPartDefect(HeaderDefect): ...
+
+if sys.version_info >= (3, 10):
+    class InvalidDateDefect(HeaderDefect): ...

mypy/typeshed/stdlib/email/feedparser.pyi

@@ -0,0 +1,23 @@
+from collections.abc import Callable
+from email.message import Message
+from email.policy import Policy
+from typing import Generic, TypeVar, overload
+
+__all__ = ["FeedParser", "BytesFeedParser"]
+
+_MessageT = TypeVar("_MessageT", bound=Message)
+
+class FeedParser(Generic[_MessageT]):
+    @overload
+    def __init__(self: FeedParser[Message], _factory: None = None, *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def feed(self, data: str) -> None: ...
+    def close(self) -> _MessageT: ...
+
+class BytesFeedParser(FeedParser[_MessageT]):
+    @overload
+    def __init__(self: BytesFeedParser[Message], _factory: None = None, *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def feed(self, data: bytes | bytearray) -> None: ...  # type: ignore[override]

mypy/typeshed/stdlib/email/generator.pyi

@@ -0,0 +1,40 @@
+from _typeshed import SupportsWrite
+from email.message import Message
+from email.policy import Policy
+from typing_extensions import Self
+
+__all__ = ["Generator", "DecodedGenerator", "BytesGenerator"]
+
+class Generator:
+    def clone(self, fp: SupportsWrite[str]) -> Self: ...
+    def write(self, s: str) -> None: ...
+    def __init__(
+        self,
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: Policy | None = None,
+    ) -> None: ...
+    def flatten(self, msg: Message, unixfrom: bool = False, linesep: str | None = None) -> None: ...
+
+class BytesGenerator(Generator):
+    def __init__(
+        self,
+        outfp: SupportsWrite[bytes],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: Policy | None = None,
+    ) -> None: ...
+
+class DecodedGenerator(Generator):
+    def __init__(
+        self,
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        fmt: str | None = None,
+        *,
+        policy: Policy | None = None,
+    ) -> None: ...

mypy/typeshed/stdlib/email/header.pyi

@@ -0,0 +1,31 @@
+from collections.abc import Iterable
+from email.charset import Charset
+from typing import Any
+
+__all__ = ["Header", "decode_header", "make_header"]
+
+class Header:
+    def __init__(
+        self,
+        s: bytes | bytearray | str | None = None,
+        charset: Charset | str | None = None,
+        maxlinelen: int | None = None,
+        header_name: str | None = None,
+        continuation_ws: str = " ",
+        errors: str = "strict",
+    ) -> None: ...
+    def append(self, s: bytes | bytearray | str, charset: Charset | str | None = None, errors: str = "strict") -> None: ...
+    def encode(self, splitchars: str = ";, \t", maxlinelen: int | None = None, linesep: str = "\n") -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, __value: object) -> bool: ...
+
+# decode_header() either returns list[tuple[str, None]] if the header
+# contains no encoded parts, or list[tuple[bytes, str | None]] if the header
+# contains at least one encoded part.
+def decode_header(header: Header | str) -> list[tuple[Any, Any | None]]: ...
+def make_header(
+    decoded_seq: Iterable[tuple[bytes | bytearray | str, str | None]],
+    maxlinelen: int | None = None,
+    header_name: str | None = None,
+    continuation_ws: str = " ",
+) -> Header: ...

mypy/typeshed/stdlib/email/headerregistry.pyi

@@ -0,0 +1,178 @@
+import types
+from collections.abc import Iterable, Mapping
+from datetime import datetime as _datetime
+from email._header_value_parser import (
+    AddressList,
+    ContentDisposition,
+    ContentTransferEncoding,
+    ContentType,
+    MessageID,
+    MIMEVersion,
+    TokenList,
+    UnstructuredTokenList,
+)
+from email.errors import MessageDefect
+from email.policy import Policy
+from typing import Any, ClassVar, Literal, Protocol
+from typing_extensions import Self
+
+class BaseHeader(str):
+    # max_count is actually more of an abstract ClassVar (not defined on the base class, but expected to be defined in subclasses)
+    max_count: ClassVar[Literal[1] | None]
+    @property
+    def name(self) -> str: ...
+    @property
+    def defects(self) -> tuple[MessageDefect, ...]: ...
+    def __new__(cls, name: str, value: Any) -> Self: ...
+    def init(self, name: str, *, parse_tree: TokenList, defects: Iterable[MessageDefect]) -> None: ...
+    def fold(self, *, policy: Policy) -> str: ...
+
+class UnstructuredHeader:
+    max_count: ClassVar[Literal[1] | None]
+    @staticmethod
+    def value_parser(value: str) -> UnstructuredTokenList: ...
+    @classmethod
+    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+
+class UniqueUnstructuredHeader(UnstructuredHeader):
+    max_count: ClassVar[Literal[1]]
+
+class DateHeader:
+    max_count: ClassVar[Literal[1] | None]
+    def init(self, name: str, *, parse_tree: TokenList, defects: Iterable[MessageDefect], datetime: _datetime) -> None: ...
+    @property
+    def datetime(self) -> _datetime: ...
+    @staticmethod
+    def value_parser(value: str) -> UnstructuredTokenList: ...
+    @classmethod
+    def parse(cls, value: str | _datetime, kwds: dict[str, Any]) -> None: ...
+
+class UniqueDateHeader(DateHeader):
+    max_count: ClassVar[Literal[1]]
+
+class AddressHeader:
+    max_count: ClassVar[Literal[1] | None]
+    def init(self, name: str, *, parse_tree: TokenList, defects: Iterable[MessageDefect], groups: Iterable[Group]) -> None: ...
+    @property
+    def groups(self) -> tuple[Group, ...]: ...
+    @property
+    def addresses(self) -> tuple[Address, ...]: ...
+    @staticmethod
+    def value_parser(value: str) -> AddressList: ...
+    @classmethod
+    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+
+class UniqueAddressHeader(AddressHeader):
+    max_count: ClassVar[Literal[1]]
+
+class SingleAddressHeader(AddressHeader):
+    @property
+    def address(self) -> Address: ...
+
+class UniqueSingleAddressHeader(SingleAddressHeader):
+    max_count: ClassVar[Literal[1]]
+
+class MIMEVersionHeader:
+    max_count: ClassVar[Literal[1]]
+    def init(
+        self,
+        name: str,
+        *,
+        parse_tree: TokenList,
+        defects: Iterable[MessageDefect],
+        version: str | None,
+        major: int | None,
+        minor: int | None,
+    ) -> None: ...
+    @property
+    def version(self) -> str | None: ...
+    @property
+    def major(self) -> int | None: ...
+    @property
+    def minor(self) -> int | None: ...
+    @staticmethod
+    def value_parser(value: str) -> MIMEVersion: ...
+    @classmethod
+    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+
+class ParameterizedMIMEHeader:
+    max_count: ClassVar[Literal[1]]
+    def init(self, name: str, *, parse_tree: TokenList, defects: Iterable[MessageDefect], params: Mapping[str, Any]) -> None: ...
+    @property
+    def params(self) -> types.MappingProxyType[str, Any]: ...
+    @classmethod
+    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+
+class ContentTypeHeader(ParameterizedMIMEHeader):
+    @property
+    def content_type(self) -> str: ...
+    @property
+    def maintype(self) -> str: ...
+    @property
+    def subtype(self) -> str: ...
+    @staticmethod
+    def value_parser(value: str) -> ContentType: ...
+
+class ContentDispositionHeader(ParameterizedMIMEHeader):
+    # init is redefined but has the same signature as parent class, so is omitted from the stub
+    @property
+    def content_disposition(self) -> str | None: ...
+    @staticmethod
+    def value_parser(value: str) -> ContentDisposition: ...
+
+class ContentTransferEncodingHeader:
+    max_count: ClassVar[Literal[1]]
+    def init(self, name: str, *, parse_tree: TokenList, defects: Iterable[MessageDefect]) -> None: ...
+    @property
+    def cte(self) -> str: ...
+    @classmethod
+    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+    @staticmethod
+    def value_parser(value: str) -> ContentTransferEncoding: ...
+
+class MessageIDHeader:
+    max_count: ClassVar[Literal[1]]
+    @classmethod
+    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+    @staticmethod
+    def value_parser(value: str) -> MessageID: ...
+
+class _HeaderParser(Protocol):
+    max_count: ClassVar[Literal[1] | None]
+    @staticmethod
+    def value_parser(__value: str) -> TokenList: ...
+    @classmethod
+    def parse(cls, __value: str, __kwds: dict[str, Any]) -> None: ...
+
+class HeaderRegistry:
+    registry: dict[str, type[_HeaderParser]]
+    base_class: type[BaseHeader]
+    default_class: type[_HeaderParser]
+    def __init__(
+        self, base_class: type[BaseHeader] = ..., default_class: type[_HeaderParser] = ..., use_default_map: bool = True
+    ) -> None: ...
+    def map_to_type(self, name: str, cls: type[BaseHeader]) -> None: ...
+    def __getitem__(self, name: str) -> type[BaseHeader]: ...
+    def __call__(self, name: str, value: Any) -> BaseHeader: ...
+
+class Address:
+    @property
+    def display_name(self) -> str: ...
+    @property
+    def username(self) -> str: ...
+    @property
+    def domain(self) -> str: ...
+    @property
+    def addr_spec(self) -> str: ...
+    def __init__(
+        self, display_name: str = "", username: str | None = "", domain: str | None = "", addr_spec: str | None = None
+    ) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class Group:
+    @property
+    def display_name(self) -> str | None: ...
+    @property
+    def addresses(self) -> tuple[Address, ...]: ...
+    def __init__(self, display_name: str | None = None, addresses: Iterable[Address] | None = None) -> None: ...
+    def __eq__(self, other: object) -> bool: ...

mypy/typeshed/stdlib/email/iterators.pyi

@@ -0,0 +1,12 @@
+from _typeshed import SupportsWrite
+from collections.abc import Iterator
+from email.message import Message
+
+__all__ = ["body_line_iterator", "typed_subpart_iterator", "walk"]
+
+def body_line_iterator(msg: Message, decode: bool = False) -> Iterator[str]: ...
+def typed_subpart_iterator(msg: Message, maintype: str = "text", subtype: str | None = None) -> Iterator[str]: ...
+def walk(self: Message) -> Iterator[Message]: ...
+
+# We include the seemingly private function because it is documented in the stdlib documentation.
+def _structure(msg: Message, fp: SupportsWrite[str] | None = None, level: int = 0, include_default: bool = False) -> None: ...

mypy/typeshed/stdlib/email/message.pyi

@@ -0,0 +1,161 @@
+from collections.abc import Generator, Iterator, Sequence
+from email import _ParamsType, _ParamType
+from email.charset import Charset
+from email.contentmanager import ContentManager
+from email.errors import MessageDefect
+from email.header import Header
+from email.policy import Policy
+from typing import Any, Literal, Protocol, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+__all__ = ["Message", "EmailMessage"]
+
+_T = TypeVar("_T")
+_PayloadType: TypeAlias = Message | str
+_EncodedPayloadType: TypeAlias = Message | bytes
+_MultipartPayloadType: TypeAlias = list[_PayloadType]
+_CharsetType: TypeAlias = Charset | str | None
+# Type returned by Policy.header_fetch_parse, AnyOf[str | Header]
+_HeaderType: TypeAlias = Any
+_HeaderTypeParam: TypeAlias = str | Header
+
+class _SupportsEncodeToPayload(Protocol):
+    def encode(self, __encoding: str) -> _PayloadType | _MultipartPayloadType | _SupportsDecodeToPayload: ...
+
+class _SupportsDecodeToPayload(Protocol):
+    def decode(self, __encoding: str, __errors: str) -> _PayloadType | _MultipartPayloadType: ...
+
+class Message:
+    policy: Policy  # undocumented
+    preamble: str | None
+    epilogue: str | None
+    defects: list[MessageDefect]
+    def is_multipart(self) -> bool: ...
+    def set_unixfrom(self, unixfrom: str) -> None: ...
+    def get_unixfrom(self) -> str | None: ...
+    def attach(self, payload: _PayloadType) -> None: ...
+    # `i: int` without a multipart payload results in an error
+    # `| Any`: can be None for cleared or unset payload, but annoying to check
+    @overload  # multipart
+    def get_payload(self, i: int, decode: Literal[True]) -> None: ...
+    @overload  # multipart
+    def get_payload(self, i: int, decode: Literal[False] = False) -> _PayloadType | Any: ...
+    @overload  # either
+    def get_payload(self, i: None = None, decode: Literal[False] = False) -> _PayloadType | _MultipartPayloadType | Any: ...
+    @overload  # not multipart
+    def get_payload(self, i: None = None, *, decode: Literal[True]) -> _EncodedPayloadType | Any: ...
+    @overload  # not multipart, IDEM but w/o kwarg
+    def get_payload(self, i: None, decode: Literal[True]) -> _EncodedPayloadType | Any: ...
+    # If `charset=None` and payload supports both `encode` AND `decode`, then an invalid payload could be passed, but this is unlikely
+    # Not[_SupportsEncodeToPayload]
+    @overload
+    def set_payload(
+        self, payload: _SupportsDecodeToPayload | _PayloadType | _MultipartPayloadType, charset: None = None
+    ) -> None: ...
+    @overload
+    def set_payload(
+        self,
+        payload: _SupportsEncodeToPayload | _SupportsDecodeToPayload | _PayloadType | _MultipartPayloadType,
+        charset: Charset | str,
+    ) -> None: ...
+    def set_charset(self, charset: _CharsetType) -> None: ...
+    def get_charset(self) -> _CharsetType: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, name: str) -> bool: ...
+    def __iter__(self) -> Iterator[str]: ...
+    # Same as `get` with `failobj=None`, but with the expectation that it won't return None in most scenarios
+    # This is important for protocols using __getitem__, like SupportsKeysAndGetItem
+    # Morally, the return type should be `AnyOf[_HeaderType, None]`,
+    # which we could spell as `_HeaderType | Any`,
+    # *but* `_HeaderType` itself is currently an alias to `Any`...
+    def __getitem__(self, name: str) -> _HeaderType: ...
+    def __setitem__(self, name: str, val: _HeaderTypeParam) -> None: ...
+    def __delitem__(self, name: str) -> None: ...
+    def keys(self) -> list[str]: ...
+    def values(self) -> list[_HeaderType]: ...
+    def items(self) -> list[tuple[str, _HeaderType]]: ...
+    @overload
+    def get(self, name: str, failobj: None = None) -> _HeaderType | None: ...
+    @overload
+    def get(self, name: str, failobj: _T) -> _HeaderType | _T: ...
+    @overload
+    def get_all(self, name: str, failobj: None = None) -> list[_HeaderType] | None: ...
+    @overload
+    def get_all(self, name: str, failobj: _T) -> list[_HeaderType] | _T: ...
+    def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ...
+    def replace_header(self, _name: str, _value: _HeaderTypeParam) -> 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: ...
+    @overload
+    def get_params(
+        self, failobj: None = None, header: str = "content-type", unquote: bool = True
+    ) -> list[tuple[str, str]] | None: ...
+    @overload
+    def get_params(self, failobj: _T, header: str = "content-type", unquote: bool = True) -> list[tuple[str, str]] | _T: ...
+    @overload
+    def get_param(
+        self, param: str, failobj: None = None, header: str = "content-type", unquote: bool = True
+    ) -> _ParamType | None: ...
+    @overload
+    def get_param(self, param: str, failobj: _T, header: str = "content-type", unquote: bool = True) -> _ParamType | _T: ...
+    def del_param(self, param: str, header: str = "content-type", requote: bool = True) -> None: ...
+    def set_type(self, type: str, header: str = "Content-Type", requote: bool = True) -> None: ...
+    @overload
+    def get_filename(self, failobj: None = None) -> str | None: ...
+    @overload
+    def get_filename(self, failobj: _T) -> str | _T: ...
+    @overload
+    def get_boundary(self, failobj: None = None) -> str | None: ...
+    @overload
+    def get_boundary(self, failobj: _T) -> str | _T: ...
+    def set_boundary(self, boundary: str) -> None: ...
+    @overload
+    def get_content_charset(self) -> str | None: ...
+    @overload
+    def get_content_charset(self, failobj: _T) -> str | _T: ...
+    @overload
+    def get_charsets(self, failobj: None = None) -> list[str | None]: ...
+    @overload
+    def get_charsets(self, failobj: _T) -> list[str | _T]: ...
+    def walk(self) -> Generator[Self, None, None]: ...
+    def get_content_disposition(self) -> str | None: ...
+    def as_string(self, unixfrom: bool = False, maxheaderlen: int = 0, policy: Policy | None = None) -> str: ...
+    def as_bytes(self, unixfrom: bool = False, policy: Policy | None = None) -> bytes: ...
+    def __bytes__(self) -> bytes: ...
+    def set_param(
+        self,
+        param: str,
+        value: str,
+        header: str = "Content-Type",
+        requote: bool = True,
+        charset: str | None = None,
+        language: str = "",
+        replace: bool = False,
+    ) -> None: ...
+    def __init__(self, policy: Policy = ...) -> None: ...
+    # The following two methods are undocumented, but a source code comment states that they are public API
+    def set_raw(self, name: str, value: _HeaderTypeParam) -> None: ...
+    def raw_items(self) -> Iterator[tuple[str, _HeaderType]]: ...
+
+class MIMEPart(Message):
+    def __init__(self, policy: Policy | None = None) -> None: ...
+    def get_body(self, preferencelist: Sequence[str] = ("related", "html", "plain")) -> Message | None: ...
+    def iter_attachments(self) -> Iterator[Message]: ...
+    def iter_parts(self) -> Iterator[Message]: ...
+    def get_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> Any: ...
+    def set_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> None: ...
+    def make_related(self, boundary: str | None = None) -> None: ...
+    def make_alternative(self, boundary: str | None = None) -> None: ...
+    def make_mixed(self, boundary: str | None = None) -> None: ...
+    def add_related(self, *args: Any, content_manager: ContentManager | None = ..., **kw: Any) -> None: ...
+    def add_alternative(self, *args: Any, content_manager: ContentManager | None = ..., **kw: Any) -> None: ...
+    def add_attachment(self, *args: Any, content_manager: ContentManager | None = ..., **kw: Any) -> None: ...
+    def clear(self) -> None: ...
+    def clear_content(self) -> None: ...
+    def as_string(self, unixfrom: bool = False, maxheaderlen: int | None = None, policy: Policy | None = None) -> str: ...
+    def is_attachment(self) -> bool: ...
+
+class EmailMessage(MIMEPart): ...

mypy/typeshed/stdlib/email/mime/application.pyi

@@ -0,0 +1,17 @@
+from collections.abc import Callable
+from email import _ParamsType
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+
+__all__ = ["MIMEApplication"]
+
+class MIMEApplication(MIMENonMultipart):
+    def __init__(
+        self,
+        _data: str | bytes | bytearray,
+        _subtype: str = "octet-stream",
+        _encoder: Callable[[MIMEApplication], object] = ...,
+        *,
+        policy: Policy | None = None,
+        **_params: _ParamsType,
+    ) -> None: ...

mypy/typeshed/stdlib/email/mime/audio.pyi

@@ -0,0 +1,17 @@
+from collections.abc import Callable
+from email import _ParamsType
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+
+__all__ = ["MIMEAudio"]
+
+class MIMEAudio(MIMENonMultipart):
+    def __init__(
+        self,
+        _audiodata: str | bytes | bytearray,
+        _subtype: str | None = None,
+        _encoder: Callable[[MIMEAudio], object] = ...,
+        *,
+        policy: Policy | None = None,
+        **_params: _ParamsType,
+    ) -> None: ...

mypy/typeshed/stdlib/email/mime/base.pyi

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