layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/email/generator.pyi

@@ -0,0 +1,79 @@
+from _typeshed import SupportsWrite
+from email.message import Message
+from email.policy import Policy
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import Self
+
+__all__ = ["Generator", "DecodedGenerator", "BytesGenerator"]
+
+# By default, generators do not have a message policy.
+_MessageT = TypeVar("_MessageT", bound=Message[Any, Any], default=Any)
+
+class Generator(Generic[_MessageT]):
+    maxheaderlen: int | None
+    policy: Policy[_MessageT] | None
+
+    @overload
+    def __init__(
+        self: Generator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: Policy[_MessageT],
+    ) -> None: ...
+
+    def write(self, s: str) -> None: ...
+    def flatten(self, msg: _MessageT, unixfrom: bool = False, linesep: str | None = None) -> None: ...
+    def clone(self, fp: SupportsWrite[str]) -> Self: ...
+
+class BytesGenerator(Generator[_MessageT]):
+    @overload
+    def __init__(
+        self: BytesGenerator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[bytes],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        outfp: SupportsWrite[bytes],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: Policy[_MessageT],
+    ) -> None: ...
+
+class DecodedGenerator(Generator[_MessageT]):
+    @overload
+    def __init__(
+        self: DecodedGenerator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        fmt: str | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        fmt: str | None = None,
+        *,
+        policy: Policy[_MessageT],
+    ) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/email/header.pyi

@@ -0,0 +1,32 @@
+from collections.abc import Iterable
+from email.charset import Charset
+from typing import Any, ClassVar
+
+__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: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    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: ...

package/analyzers/project-map-python/typeshed/stdlib/email/headerregistry.pyi

@@ -0,0 +1,193 @@
+import sys
+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, type_check_only
+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 | None: ...
+    @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: ...
+
+if sys.version_info >= (3, 13):
+    from email._header_value_parser import MessageIDList
+
+    # Added in Python 3.13.12, 3.14.3
+    class ReferencesHeader:
+        max_count: ClassVar[Literal[1]]
+        @classmethod
+        def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+        @staticmethod
+        def value_parser(value: str) -> MessageIDList: ...
+
+@type_check_only
+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: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    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: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    def __eq__(self, other: object) -> bool: ...

package/analyzers/project-map-python/typeshed/stdlib/email/iterators.pyi

@@ -0,0 +1,15 @@
+from _typeshed import SupportsWrite
+from collections.abc import Iterator
+from email.message import Message
+from typing import TypeVar
+
+_T = TypeVar("_T", bound=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: _T, maintype: str = "text", subtype: str | None = None) -> Iterator[_T]: ...
+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: ...

package/analyzers/project-map-python/typeshed/stdlib/email/message.pyi

@@ -0,0 +1,191 @@
+from _typeshed import MaybeNone
+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.policy import Policy
+from typing import Any, Generic, Literal, Protocol, TypeAlias, TypeVar, overload, type_check_only
+from typing_extensions import Self
+
+__all__ = ["Message", "EmailMessage"]
+
+_T = TypeVar("_T")
+# Type returned by Policy.header_fetch_parse, often str or Header.
+_HeaderT_co = TypeVar("_HeaderT_co", covariant=True, default=str)
+_HeaderParamT_contra = TypeVar("_HeaderParamT_contra", contravariant=True, default=str)
+# Represents headers constructed by HeaderRegistry. Those are sub-classes
+# of BaseHeader and another header type.
+_HeaderRegistryT_co = TypeVar("_HeaderRegistryT_co", covariant=True, default=Any)
+_HeaderRegistryParamT_contra = TypeVar("_HeaderRegistryParamT_contra", contravariant=True, default=Any)
+
+_PayloadType: TypeAlias = Message | str
+_EncodedPayloadType: TypeAlias = Message | bytes
+_MultipartPayloadType: TypeAlias = list[_PayloadType]
+_CharsetType: TypeAlias = Charset | str | None
+
+@type_check_only
+class _SupportsEncodeToPayload(Protocol):
+    def encode(self, encoding: str, /) -> _PayloadType | _MultipartPayloadType | _SupportsDecodeToPayload: ...
+
+@type_check_only
+class _SupportsDecodeToPayload(Protocol):
+    def decode(self, encoding: str, errors: str, /) -> _PayloadType | _MultipartPayloadType: ...
+
+class Message(Generic[_HeaderT_co, _HeaderParamT_contra]):
+    # The policy attributes and arguments in this class and its subclasses
+    # would ideally use Policy[Self], but this is not possible.
+    policy: Policy[Any]  # undocumented
+    preamble: str | None
+    epilogue: str | None
+    defects: list[MessageDefect]
+    def __init__(self, policy: Policy[Any] = ...) -> None: ...
+    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
+    # `| MaybeNone` acts like `| 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 | MaybeNone: ...
+    @overload  # either
+    def get_payload(self, i: None = None, decode: Literal[False] = False) -> _PayloadType | _MultipartPayloadType | MaybeNone: ...
+    @overload  # not multipart
+    def get_payload(self, i: None = None, *, decode: Literal[True]) -> _EncodedPayloadType | MaybeNone: ...
+    @overload  # not multipart, IDEM but w/o kwarg
+    def get_payload(self, i: None, decode: Literal[True]) -> _EncodedPayloadType | MaybeNone: ...
+
+    # 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]`,
+    # so using "the Any trick" instead.
+    def __getitem__(self, name: str) -> _HeaderT_co | MaybeNone: ...
+    def __setitem__(self, name: str, val: _HeaderParamT_contra) -> None: ...
+    def __delitem__(self, name: str) -> None: ...
+    def keys(self) -> list[str]: ...
+    def values(self) -> list[_HeaderT_co]: ...
+    def items(self) -> list[tuple[str, _HeaderT_co]]: ...
+
+    @overload
+    def get(self, name: str, failobj: None = None) -> _HeaderT_co | None: ...
+    @overload
+    def get(self, name: str, failobj: _T) -> _HeaderT_co | _T: ...
+
+    @overload
+    def get_all(self, name: str, failobj: None = None) -> list[_HeaderT_co] | None: ...
+    @overload
+    def get_all(self, name: str, failobj: _T) -> list[_HeaderT_co] | _T: ...
+
+    def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ...
+    def replace_header(self, _name: str, _value: _HeaderParamT_contra) -> 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]: ...
+    def get_content_disposition(self) -> str | None: ...
+    def as_string(self, unixfrom: bool = False, maxheaderlen: int = 0, policy: Policy[Any] | None = None) -> str: ...
+    def as_bytes(self, unixfrom: bool = False, policy: Policy[Any] | 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: ...
+    # The following two methods are undocumented, but a source code comment states that they are public API
+    def set_raw(self, name: str, value: _HeaderParamT_contra) -> None: ...
+    def raw_items(self) -> Iterator[tuple[str, _HeaderT_co]]: ...
+
+class MIMEPart(Message[_HeaderRegistryT_co, _HeaderRegistryParamT_contra]):
+    def __init__(self, policy: Policy[Any] | None = None) -> None: ...
+    def get_body(
+        self, preferencelist: Sequence[str] = ("related", "html", "plain")
+    ) -> MIMEPart[_HeaderRegistryT_co, _HeaderRegistryParamT_contra] | None: ...
+    def attach(self, payload: Self) -> None: ...  # type: ignore[override]
+    # The attachments are created via type(self) in the attach method. It's theoretically
+    # possible to sneak other attachment types into a MIMEPart instance, but could cause
+    # cause unforseen consequences.
+    def iter_attachments(self) -> Iterator[Self]: ...
+    def iter_parts(self) -> Iterator[MIMEPart[_HeaderRegistryT_co, _HeaderRegistryParamT_contra]]: ...
+    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[Any] | None = None) -> str: ...
+    def is_attachment(self) -> bool: ...
+
+class EmailMessage(MIMEPart[_HeaderRegistryT_co, _HeaderRegistryParamT_contra]): ...

package/analyzers/project-map-python/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: ...

package/analyzers/project-map-python/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: ...

package/analyzers/project-map-python/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: ...

package/analyzers/project-map-python/typeshed/stdlib/email/mime/image.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__ = ["MIMEImage"]
+
+class MIMEImage(MIMENonMultipart):
+    def __init__(
+        self,
+        _imagedata: str | bytes | bytearray,
+        _subtype: str | None = None,
+        _encoder: Callable[[MIMEImage], object] = ...,
+        *,
+        policy: Policy | None = None,
+        **_params: _ParamsType,
+    ) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/email/mime/message.pyi

@@ -0,0 +1,8 @@
+from email._policybase import _MessageT
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+
+__all__ = ["MIMEMessage"]
+
+class MIMEMessage(MIMENonMultipart):
+    def __init__(self, _msg: _MessageT, _subtype: str = "rfc822", *, policy: Policy[_MessageT] | None = None) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/email/mime/multipart.pyi

@@ -0,0 +1,18 @@
+from collections.abc import Sequence
+from email import _ParamsType
+from email._policybase import _MessageT
+from email.mime.base import MIMEBase
+from email.policy import Policy
+
+__all__ = ["MIMEMultipart"]
+
+class MIMEMultipart(MIMEBase):
+    def __init__(
+        self,
+        _subtype: str = "mixed",
+        boundary: str | None = None,
+        _subparts: Sequence[_MessageT] | None = None,
+        *,
+        policy: Policy[_MessageT] | None = None,
+        **_params: _ParamsType,
+    ) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/email/mime/nonmultipart.pyi

@@ -0,0 +1,5 @@
+from email.mime.base import MIMEBase
+
+__all__ = ["MIMENonMultipart"]
+
+class MIMENonMultipart(MIMEBase): ...

package/analyzers/project-map-python/typeshed/stdlib/email/mime/text.pyi

@@ -0,0 +1,9 @@
+from email._policybase import Policy
+from email.mime.nonmultipart import MIMENonMultipart
+
+__all__ = ["MIMEText"]
+
+class MIMEText(MIMENonMultipart):
+    def __init__(
+        self, _text: str, _subtype: str = "plain", _charset: str | None = None, *, policy: Policy | None = None
+    ) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/email/parser.pyi

@@ -0,0 +1,42 @@
+from _typeshed import SupportsRead
+from collections.abc import Callable
+from email._policybase import _MessageT
+from email.feedparser import BytesFeedParser as BytesFeedParser, FeedParser as FeedParser
+from email.message import Message
+from email.policy import Policy
+from io import _WrappedBuffer
+from typing import Generic, overload
+
+__all__ = ["Parser", "HeaderParser", "BytesParser", "BytesHeaderParser", "FeedParser", "BytesFeedParser"]
+
+class Parser(Generic[_MessageT]):
+    @overload
+    def __init__(self: Parser[Message[str, str]], _class: None = None) -> None: ...
+    @overload
+    def __init__(self, _class: None = None, *, policy: Policy[_MessageT]) -> None: ...
+    @overload
+    def __init__(self, _class: Callable[[], _MessageT] | None, *, policy: Policy[_MessageT] = ...) -> None: ...
+
+    def parse(self, fp: SupportsRead[str], headersonly: bool = False) -> _MessageT: ...
+    def parsestr(self, text: str, headersonly: bool = False) -> _MessageT: ...
+
+class HeaderParser(Parser[_MessageT]):
+    def parse(self, fp: SupportsRead[str], headersonly: bool = True) -> _MessageT: ...
+    def parsestr(self, text: str, headersonly: bool = True) -> _MessageT: ...
+
+class BytesParser(Generic[_MessageT]):
+    parser: Parser[_MessageT]
+
+    @overload
+    def __init__(self: BytesParser[Message[str, str]], _class: None = None) -> None: ...
+    @overload
+    def __init__(self, _class: None = None, *, policy: Policy[_MessageT]) -> None: ...
+    @overload
+    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
+
+    def parse(self, fp: _WrappedBuffer, headersonly: bool = False) -> _MessageT: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = False) -> _MessageT: ...
+
+class BytesHeaderParser(BytesParser[_MessageT]):
+    def parse(self, fp: _WrappedBuffer, headersonly: bool = True) -> _MessageT: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = True) -> _MessageT: ...