jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

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

@@ -1,178 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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, often str or Header.
-_HeaderType: TypeAlias = Any
-# Type accepted by Policy.header_store_parse.
-_HeaderTypeParam: TypeAlias = str | Header | Any
-
-class _SupportsEncodeToPayload(Protocol):
-    def encode(self, encoding: str, /) -> _PayloadType | _MultipartPayloadType | _SupportsDecodeToPayload: ...
-
-class _SupportsDecodeToPayload(Protocol):
-    def decode(self, encoding: str, errors: str, /) -> _PayloadType | _MultipartPayloadType: ...
-
-# TODO: This class should be generic over the header policy and/or the header
-# value types allowed by the policy. This depends on PEP 696 support
-# (https://github.com/python/typeshed/issues/11422).
-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

@@ -1,17 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

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

@@ -1,28 +0,0 @@
-from collections.abc import Iterable
-
-__all__ = [
-    "body_decode",
-    "body_encode",
-    "body_length",
-    "decode",
-    "decodestring",
-    "header_decode",
-    "header_encode",
-    "header_length",
-    "quote",
-    "unquote",
-]
-
-def header_check(octet: int) -> bool: ...
-def body_check(octet: int) -> bool: ...
-def header_length(bytearray: Iterable[int]) -> int: ...
-def body_length(bytearray: Iterable[int]) -> int: ...
-def unquote(s: str | bytes | bytearray) -> str: ...
-def quote(c: str | bytes | bytearray) -> str: ...
-def header_encode(header_bytes: bytes | bytearray, charset: str = "iso-8859-1") -> str: ...
-def body_encode(body: str, maxlinelen: int = 76, eol: str = "\n") -> str: ...
-def decode(encoded: str, eol: str = "\n") -> str: ...
-def header_decode(s: str) -> str: ...
-
-body_decode = decode
-decodestring = decode

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

@@ -1,70 +0,0 @@
-import datetime
-import sys
-from _typeshed import Unused
-from email import _ParamType
-from email.charset import Charset
-from typing import overload
-from typing_extensions import TypeAlias, deprecated
-
-__all__ = [
-    "collapse_rfc2231_value",
-    "decode_params",
-    "decode_rfc2231",
-    "encode_rfc2231",
-    "formataddr",
-    "formatdate",
-    "format_datetime",
-    "getaddresses",
-    "make_msgid",
-    "mktime_tz",
-    "parseaddr",
-    "parsedate",
-    "parsedate_tz",
-    "parsedate_to_datetime",
-    "unquote",
-]
-
-_PDTZ: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int | None]
-
-def quote(str: str) -> str: ...
-def unquote(str: str) -> str: ...
-def parseaddr(addr: str | None) -> tuple[str, str]: ...
-def formataddr(pair: tuple[str | None, str], charset: str | Charset = "utf-8") -> str: ...
-def getaddresses(fieldvalues: list[str]) -> list[tuple[str, str]]: ...
-@overload
-def parsedate(data: None) -> None: ...
-@overload
-def parsedate(data: str) -> tuple[int, int, int, int, int, int, int, int, int] | None: ...
-@overload
-def parsedate_tz(data: None) -> None: ...
-@overload
-def parsedate_tz(data: str) -> _PDTZ | None: ...
-
-if sys.version_info >= (3, 10):
-    @overload
-    def parsedate_to_datetime(data: None) -> None: ...
-    @overload
-    def parsedate_to_datetime(data: str) -> datetime.datetime: ...
-
-else:
-    def parsedate_to_datetime(data: str) -> datetime.datetime: ...
-
-def mktime_tz(data: _PDTZ) -> int: ...
-def formatdate(timeval: float | None = None, localtime: bool = False, usegmt: bool = False) -> str: ...
-def format_datetime(dt: datetime.datetime, usegmt: bool = False) -> str: ...
-
-if sys.version_info >= (3, 12):
-    @overload
-    def localtime(dt: datetime.datetime | None = None) -> datetime.datetime: ...
-    @overload
-    @deprecated("The `isdst` parameter does nothing and will be removed in Python 3.14.")
-    def localtime(dt: datetime.datetime | None = None, isdst: Unused = None) -> datetime.datetime: ...
-
-else:
-    def localtime(dt: datetime.datetime | None = None, isdst: int = -1) -> datetime.datetime: ...
-
-def make_msgid(idstring: str | None = None, domain: str | None = None) -> str: ...
-def decode_rfc2231(s: str) -> tuple[str | None, str | None, str]: ...  # May return list[str]. See issue #10431 for details.
-def encode_rfc2231(s: str, charset: str | None = None, language: str | None = None) -> str: ...
-def collapse_rfc2231_value(value: _ParamType, errors: str = "replace", fallback_charset: str = "us-ascii") -> str: ...
-def decode_params(params: list[tuple[str, str]]) -> list[tuple[str, _ParamType]]: ...

jaclang/vendor/mypy/typeshed/stdlib/encodings/__init__.pyi

@@ -1,10 +0,0 @@
-from _typeshed import Incomplete
-from codecs import CodecInfo
-
-class CodecRegistryError(LookupError, SystemError): ...
-
-def normalize_encoding(encoding: str | bytes) -> str: ...
-def search_function(encoding: str) -> CodecInfo | None: ...
-
-# Needed for submodules
-def __getattr__(name: str) -> Incomplete: ...

jaclang/vendor/mypy/typeshed/stdlib/encodings/utf_8.pyi

@@ -1,21 +0,0 @@
-import codecs
-from _typeshed import ReadableBuffer
-
-class IncrementalEncoder(codecs.IncrementalEncoder):
-    def encode(self, input: str, final: bool = False) -> bytes: ...
-
-class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-    @staticmethod
-    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
-
-class StreamWriter(codecs.StreamWriter):
-    @staticmethod
-    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
-
-class StreamReader(codecs.StreamReader):
-    @staticmethod
-    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
-
-def getregentry() -> codecs.CodecInfo: ...
-def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
-def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...