jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/email/headerregistry.pyi

@@ -0,0 +1,214 @@
+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: ...

jaclang/vendor/mypy/typeshed/stdlib/email/iterators.pyi

@@ -0,0 +1,19 @@
+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: ...

jaclang/vendor/mypy/typeshed/stdlib/email/message.pyi

@@ -0,0 +1,220 @@
+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): ...

jaclang/vendor/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: ...

jaclang/vendor/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: ...

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

@@ -0,0 +1,15 @@
+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: ...

jaclang/vendor/mypy/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: ...

jaclang/vendor/mypy/typeshed/stdlib/email/mime/message.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/email/mime/multipart.pyi

@@ -0,0 +1,18 @@
+from collections.abc import Sequence
+from email import _ParamsType
+from email.message import Message
+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[Message] | None = None,
+        *,
+        policy: Policy | None = None,
+        **_params: _ParamsType,
+    ) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/email/mime/nonmultipart.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/email/mime/text.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/email/parser.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/email/policy.pyi

@@ -0,0 +1,51 @@
+from collections.abc import Callable
+from email._policybase import (
+    Compat32 as Compat32,
+    Policy as Policy,
+    compat32 as compat32,
+)
+from email.contentmanager import ContentManager
+from email.message import Message
+from typing import Any
+
+__all__ = [
+    "Compat32",
+    "compat32",
+    "Policy",
+    "EmailPolicy",
+    "default",
+    "strict",
+    "SMTP",
+    "HTTP",
+]
+
+class EmailPolicy(Policy):
+    utf8: bool
+    refold_source: str
+    header_factory: Callable[[str, Any], Any]
+    content_manager: ContentManager
+    def __init__(
+        self,
+        *,
+        max_line_length: int | None = ...,
+        linesep: str = ...,
+        cte_type: str = ...,
+        raise_on_defect: bool = ...,
+        mangle_from_: bool = ...,
+        message_factory: Callable[[Policy], Message] | None = ...,
+        utf8: bool = ...,
+        refold_source: str = ...,
+        header_factory: Callable[[str, str], str] = ...,
+        content_manager: ContentManager = ...,
+    ) -> None: ...
+    def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
+    def header_store_parse(self, name: str, value: Any) -> tuple[str, Any]: ...
+    def header_fetch_parse(self, name: str, value: str) -> Any: ...
+    def fold(self, name: str, value: str) -> Any: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+default: EmailPolicy
+SMTP: EmailPolicy
+SMTPUTF8: EmailPolicy
+HTTP: EmailPolicy
+strict: EmailPolicy