jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/shutil.pyi

@@ -1,185 +0,0 @@
-import os
-import sys
-from _typeshed import BytesPath, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
-from collections.abc import Callable, Iterable, Sequence
-from tarfile import _TarfileFilter
-from typing import Any, AnyStr, NamedTuple, Protocol, TypeVar, overload
-from typing_extensions import TypeAlias, deprecated
-
-__all__ = [
-    "copyfileobj",
-    "copyfile",
-    "copymode",
-    "copystat",
-    "copy",
-    "copy2",
-    "copytree",
-    "move",
-    "rmtree",
-    "Error",
-    "SpecialFileError",
-    "ExecError",
-    "make_archive",
-    "get_archive_formats",
-    "register_archive_format",
-    "unregister_archive_format",
-    "get_unpack_formats",
-    "register_unpack_format",
-    "unregister_unpack_format",
-    "unpack_archive",
-    "ignore_patterns",
-    "chown",
-    "which",
-    "get_terminal_size",
-    "SameFileError",
-    "disk_usage",
-]
-
-_StrOrBytesPathT = TypeVar("_StrOrBytesPathT", bound=StrOrBytesPath)
-_StrPathT = TypeVar("_StrPathT", bound=StrPath)
-# Return value of some functions that may either return a path-like object that was passed in or
-# a string
-_PathReturn: TypeAlias = Any
-
-class Error(OSError): ...
-class SameFileError(Error): ...
-class SpecialFileError(OSError): ...
-class ExecError(OSError): ...
-class ReadError(OSError): ...
-class RegistryError(Exception): ...
-
-def copyfileobj(fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr], length: int = 0) -> None: ...
-def copyfile(src: StrOrBytesPath, dst: _StrOrBytesPathT, *, follow_symlinks: bool = True) -> _StrOrBytesPathT: ...
-def copymode(src: StrOrBytesPath, dst: StrOrBytesPath, *, follow_symlinks: bool = True) -> None: ...
-def copystat(src: StrOrBytesPath, dst: StrOrBytesPath, *, follow_symlinks: bool = True) -> None: ...
-@overload
-def copy(src: StrPath, dst: StrPath, *, follow_symlinks: bool = True) -> _PathReturn: ...
-@overload
-def copy(src: BytesPath, dst: BytesPath, *, follow_symlinks: bool = True) -> _PathReturn: ...
-@overload
-def copy2(src: StrPath, dst: StrPath, *, follow_symlinks: bool = True) -> _PathReturn: ...
-@overload
-def copy2(src: BytesPath, dst: BytesPath, *, follow_symlinks: bool = True) -> _PathReturn: ...
-def ignore_patterns(*patterns: StrPath) -> Callable[[Any, list[str]], set[str]]: ...
-def copytree(
-    src: StrPath,
-    dst: StrPath,
-    symlinks: bool = False,
-    ignore: None | Callable[[str, list[str]], Iterable[str]] | Callable[[StrPath, list[str]], Iterable[str]] = None,
-    copy_function: Callable[[str, str], object] = ...,
-    ignore_dangling_symlinks: bool = False,
-    dirs_exist_ok: bool = False,
-) -> _PathReturn: ...
-
-_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, Any], object]
-_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, Exception], object]
-
-class _RmtreeType(Protocol):
-    avoids_symlink_attacks: bool
-    if sys.version_info >= (3, 12):
-        @overload
-        def __call__(self, path: StrOrBytesPath, ignore_errors: bool = False, *, dir_fd: int | None = None) -> None: ...
-        @overload
-        @deprecated("The `onerror` parameter is deprecated and will be removed in Python 3.14. Use `onexc` instead.")
-        def __call__(
-            self,
-            path: StrOrBytesPath,
-            ignore_errors: bool = False,
-            onerror: _OnErrorCallback | None = None,
-            *,
-            dir_fd: int | None = None,
-        ) -> None: ...
-        @overload
-        def __call__(
-            self, path: StrOrBytesPath, ignore_errors: bool = False, *, onexc: _OnExcCallback, dir_fd: int | None = None
-        ) -> None: ...
-    elif sys.version_info >= (3, 11):
-        def __call__(
-            self,
-            path: StrOrBytesPath,
-            ignore_errors: bool = False,
-            onerror: _OnErrorCallback | None = None,
-            *,
-            dir_fd: int | None = None,
-        ) -> None: ...
-
-    else:
-        def __call__(
-            self, path: StrOrBytesPath, ignore_errors: bool = False, onerror: _OnErrorCallback | None = None
-        ) -> None: ...
-
-rmtree: _RmtreeType
-
-_CopyFn: TypeAlias = Callable[[str, str], object] | Callable[[StrPath, StrPath], object]
-
-# N.B. shutil.move appears to take bytes arguments, however,
-# this does not work when dst is (or is within) an existing directory.
-# (#6832)
-if sys.version_info >= (3, 9):
-    def move(src: StrPath, dst: StrPath, copy_function: _CopyFn = ...) -> _PathReturn: ...
-
-else:
-    # See https://bugs.python.org/issue32689
-    def move(src: str, dst: StrPath, copy_function: _CopyFn = ...) -> _PathReturn: ...
-
-class _ntuple_diskusage(NamedTuple):
-    total: int
-    used: int
-    free: int
-
-def disk_usage(path: FileDescriptorOrPath) -> _ntuple_diskusage: ...
-
-# While chown can be imported on Windows, it doesn't actually work;
-# see https://bugs.python.org/issue33140. We keep it here because it's
-# in __all__.
-@overload
-def chown(path: FileDescriptorOrPath, user: str | int, group: None = None) -> None: ...
-@overload
-def chown(path: FileDescriptorOrPath, user: None = None, *, group: str | int) -> None: ...
-@overload
-def chown(path: FileDescriptorOrPath, user: None, group: str | int) -> None: ...
-@overload
-def chown(path: FileDescriptorOrPath, user: str | int, group: str | int) -> None: ...
-@overload
-def which(cmd: _StrPathT, mode: int = 1, path: StrPath | None = None) -> str | _StrPathT | None: ...
-@overload
-def which(cmd: bytes, mode: int = 1, path: StrPath | None = None) -> bytes | None: ...
-def make_archive(
-    base_name: str,
-    format: str,
-    root_dir: StrPath | None = None,
-    base_dir: StrPath | None = None,
-    verbose: bool = ...,
-    dry_run: bool = ...,
-    owner: str | None = None,
-    group: str | None = None,
-    logger: Any | None = None,
-) -> str: ...
-def get_archive_formats() -> list[tuple[str, str]]: ...
-@overload
-def register_archive_format(
-    name: str, function: Callable[..., object], extra_args: Sequence[tuple[str, Any] | list[Any]], description: str = ""
-) -> None: ...
-@overload
-def register_archive_format(
-    name: str, function: Callable[[str, str], object], extra_args: None = None, description: str = ""
-) -> None: ...
-def unregister_archive_format(name: str) -> None: ...
-def unpack_archive(
-    filename: StrPath, extract_dir: StrPath | None = None, format: str | None = None, *, filter: _TarfileFilter | None = None
-) -> None: ...
-@overload
-def register_unpack_format(
-    name: str,
-    extensions: list[str],
-    function: Callable[..., object],
-    extra_args: Sequence[tuple[str, Any]],
-    description: str = "",
-) -> None: ...
-@overload
-def register_unpack_format(
-    name: str, extensions: list[str], function: Callable[[str, str], object], extra_args: None = None, description: str = ""
-) -> None: ...
-def unregister_unpack_format(name: str) -> None: ...
-def get_unpack_formats() -> list[tuple[str, list[str], str]]: ...
-def get_terminal_size(fallback: tuple[int, int] = (80, 24)) -> os.terminal_size: ...

jaclang/vendor/mypy/typeshed/stdlib/signal.pyi

@@ -1,188 +0,0 @@
-import sys
-from _typeshed import structseq
-from collections.abc import Callable, Iterable
-from enum import IntEnum
-from types import FrameType
-from typing import Any, Final, final
-from typing_extensions import Never, TypeAlias
-
-NSIG: int
-
-class Signals(IntEnum):
-    SIGABRT: int
-    SIGFPE: int
-    SIGILL: int
-    SIGINT: int
-    SIGSEGV: int
-    SIGTERM: int
-
-    if sys.platform == "win32":
-        SIGBREAK: int
-        CTRL_C_EVENT: int
-        CTRL_BREAK_EVENT: int
-    else:
-        SIGALRM: int
-        SIGBUS: int
-        SIGCHLD: int
-        SIGCONT: int
-        SIGHUP: int
-        SIGIO: int
-        SIGIOT: int
-        SIGKILL: int
-        SIGPIPE: int
-        SIGPROF: int
-        SIGQUIT: int
-        SIGSTOP: int
-        SIGSYS: int
-        SIGTRAP: int
-        SIGTSTP: int
-        SIGTTIN: int
-        SIGTTOU: int
-        SIGURG: int
-        SIGUSR1: int
-        SIGUSR2: int
-        SIGVTALRM: int
-        SIGWINCH: int
-        SIGXCPU: int
-        SIGXFSZ: int
-        if sys.platform != "linux":
-            SIGEMT: int
-            SIGINFO: int
-        if sys.platform != "darwin":
-            SIGCLD: int
-            SIGPOLL: int
-            SIGPWR: int
-            SIGRTMAX: int
-            SIGRTMIN: int
-            if sys.version_info >= (3, 11):
-                SIGSTKFLT: int
-
-class Handlers(IntEnum):
-    SIG_DFL: int
-    SIG_IGN: int
-
-SIG_DFL: Handlers
-SIG_IGN: Handlers
-
-_SIGNUM: TypeAlias = int | Signals
-_HANDLER: TypeAlias = Callable[[int, FrameType | None], Any] | int | Handlers | None
-
-def default_int_handler(signalnum: int, frame: FrameType | None, /) -> Never: ...
-
-if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
-    def getsignal(signalnum: _SIGNUM) -> _HANDLER: ...
-    def signal(signalnum: _SIGNUM, handler: _HANDLER) -> _HANDLER: ...
-
-else:
-    def getsignal(signalnum: _SIGNUM, /) -> _HANDLER: ...
-    def signal(signalnum: _SIGNUM, handler: _HANDLER, /) -> _HANDLER: ...
-
-SIGABRT: Signals
-SIGFPE: Signals
-SIGILL: Signals
-SIGINT: Signals
-SIGSEGV: Signals
-SIGTERM: Signals
-
-if sys.platform == "win32":
-    SIGBREAK: Signals
-    CTRL_C_EVENT: Signals
-    CTRL_BREAK_EVENT: Signals
-else:
-    if sys.platform != "linux":
-        SIGINFO: Signals
-        SIGEMT: Signals
-    SIGALRM: Signals
-    SIGBUS: Signals
-    SIGCHLD: Signals
-    SIGCONT: Signals
-    SIGHUP: Signals
-    SIGIO: Signals
-    SIGIOT: Signals
-    SIGKILL: Signals
-    SIGPIPE: Signals
-    SIGPROF: Signals
-    SIGQUIT: Signals
-    SIGSTOP: Signals
-    SIGSYS: Signals
-    SIGTRAP: Signals
-    SIGTSTP: Signals
-    SIGTTIN: Signals
-    SIGTTOU: Signals
-    SIGURG: Signals
-    SIGUSR1: Signals
-    SIGUSR2: Signals
-    SIGVTALRM: Signals
-    SIGWINCH: Signals
-    SIGXCPU: Signals
-    SIGXFSZ: Signals
-
-    class ItimerError(OSError): ...
-    ITIMER_PROF: int
-    ITIMER_REAL: int
-    ITIMER_VIRTUAL: int
-
-    class Sigmasks(IntEnum):
-        SIG_BLOCK: int
-        SIG_UNBLOCK: int
-        SIG_SETMASK: int
-
-    SIG_BLOCK = Sigmasks.SIG_BLOCK
-    SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
-    SIG_SETMASK = Sigmasks.SIG_SETMASK
-    def alarm(seconds: int, /) -> int: ...
-    def getitimer(which: int, /) -> tuple[float, float]: ...
-    def pause() -> None: ...
-    def pthread_kill(thread_id: int, signalnum: int, /) -> None: ...
-    if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
-        def pthread_sigmask(how: int, mask: Iterable[int]) -> set[_SIGNUM]: ...
-    else:
-        def pthread_sigmask(how: int, mask: Iterable[int], /) -> set[_SIGNUM]: ...
-
-    def setitimer(which: int, seconds: float, interval: float = 0.0, /) -> tuple[float, float]: ...
-    def siginterrupt(signalnum: int, flag: bool, /) -> None: ...
-    def sigpending() -> Any: ...
-    if sys.version_info >= (3, 10):  # argument changed in 3.10.2
-        def sigwait(sigset: Iterable[int]) -> _SIGNUM: ...
-    else:
-        def sigwait(sigset: Iterable[int], /) -> _SIGNUM: ...
-    if sys.platform != "darwin":
-        SIGCLD: Signals
-        SIGPOLL: Signals
-        SIGPWR: Signals
-        SIGRTMAX: Signals
-        SIGRTMIN: Signals
-        if sys.version_info >= (3, 11):
-            SIGSTKFLT: Signals
-
-        @final
-        class struct_siginfo(structseq[int], tuple[int, int, int, int, int, int, int]):
-            if sys.version_info >= (3, 10):
-                __match_args__: Final = ("si_signo", "si_code", "si_errno", "si_pid", "si_uid", "si_status", "si_band")
-
-            @property
-            def si_signo(self) -> int: ...
-            @property
-            def si_code(self) -> int: ...
-            @property
-            def si_errno(self) -> int: ...
-            @property
-            def si_pid(self) -> int: ...
-            @property
-            def si_uid(self) -> int: ...
-            @property
-            def si_status(self) -> int: ...
-            @property
-            def si_band(self) -> int: ...
-
-        def sigtimedwait(sigset: Iterable[int], timeout: float, /) -> struct_siginfo | None: ...
-        def sigwaitinfo(sigset: Iterable[int], /) -> struct_siginfo: ...
-
-def strsignal(signalnum: _SIGNUM, /) -> str | None: ...
-def valid_signals() -> set[Signals]: ...
-def raise_signal(signalnum: _SIGNUM, /) -> None: ...
-def set_wakeup_fd(fd: int, *, warn_on_full_buffer: bool = ...) -> int: ...
-
-if sys.version_info >= (3, 9):
-    if sys.platform == "linux":
-        def pidfd_send_signal(pidfd: int, sig: int, siginfo: None = None, flags: int = ..., /) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/site.pyi

@@ -1,27 +0,0 @@
-from _typeshed import StrPath
-from collections.abc import Iterable
-
-PREFIXES: list[str]
-ENABLE_USER_SITE: bool | None
-USER_SITE: str | None
-USER_BASE: str | None
-
-def main() -> None: ...
-def abs_paths() -> None: ...  # undocumented
-def addpackage(sitedir: StrPath, name: StrPath, known_paths: set[str] | None) -> set[str] | None: ...  # undocumented
-def addsitedir(sitedir: str, known_paths: set[str] | None = None) -> None: ...
-def addsitepackages(known_paths: set[str] | None, prefixes: Iterable[str] | None = None) -> set[str] | None: ...  # undocumented
-def addusersitepackages(known_paths: set[str] | None) -> set[str] | None: ...  # undocumented
-def check_enableusersite() -> bool | None: ...  # undocumented
-def enablerlcompleter() -> None: ...  # undocumented
-def execsitecustomize() -> None: ...  # undocumented
-def execusercustomize() -> None: ...  # undocumented
-def getsitepackages(prefixes: Iterable[str] | None = None) -> list[str]: ...
-def getuserbase() -> str: ...
-def getusersitepackages() -> str: ...
-def makepath(*paths: StrPath) -> tuple[str, str]: ...  # undocumented
-def removeduppaths() -> set[str]: ...  # undocumented
-def setcopyright() -> None: ...  # undocumented
-def sethelper() -> None: ...  # undocumented
-def setquit() -> None: ...  # undocumented
-def venv(known_paths: set[str] | None) -> set[str] | None: ...  # undocumented

jaclang/vendor/mypy/typeshed/stdlib/smtpd.pyi

@@ -1,91 +0,0 @@
-import asynchat
-import asyncore
-import socket
-import sys
-from collections import defaultdict
-from typing import Any
-from typing_extensions import TypeAlias
-
-if sys.version_info >= (3, 11):
-    __all__ = ["SMTPChannel", "SMTPServer", "DebuggingServer", "PureProxy"]
-else:
-    __all__ = ["SMTPChannel", "SMTPServer", "DebuggingServer", "PureProxy", "MailmanProxy"]
-
-_Address: TypeAlias = tuple[str, int]  # (host, port)
-
-class SMTPChannel(asynchat.async_chat):
-    COMMAND: int
-    DATA: int
-
-    command_size_limits: defaultdict[str, int]
-    smtp_server: SMTPServer
-    conn: socket.socket
-    addr: Any
-    received_lines: list[str]
-    smtp_state: int
-    seen_greeting: str
-    mailfrom: str
-    rcpttos: list[str]
-    received_data: str
-    fqdn: str
-    peer: str
-
-    command_size_limit: int
-    data_size_limit: int
-
-    enable_SMTPUTF8: bool
-    @property
-    def max_command_size_limit(self) -> int: ...
-    def __init__(
-        self,
-        server: SMTPServer,
-        conn: socket.socket,
-        addr: Any,
-        data_size_limit: int = 33554432,
-        map: asyncore._MapType | None = None,
-        enable_SMTPUTF8: bool = False,
-        decode_data: bool = False,
-    ) -> None: ...
-    # base asynchat.async_chat.push() accepts bytes
-    def push(self, msg: str) -> None: ...  # type: ignore[override]
-    def collect_incoming_data(self, data: bytes) -> None: ...
-    def found_terminator(self) -> None: ...
-    def smtp_HELO(self, arg: str) -> None: ...
-    def smtp_NOOP(self, arg: str) -> None: ...
-    def smtp_QUIT(self, arg: str) -> None: ...
-    def smtp_MAIL(self, arg: str) -> None: ...
-    def smtp_RCPT(self, arg: str) -> None: ...
-    def smtp_RSET(self, arg: str) -> None: ...
-    def smtp_DATA(self, arg: str) -> None: ...
-    def smtp_EHLO(self, arg: str) -> None: ...
-    def smtp_HELP(self, arg: str) -> None: ...
-    def smtp_VRFY(self, arg: str) -> None: ...
-    def smtp_EXPN(self, arg: str) -> None: ...
-
-class SMTPServer(asyncore.dispatcher):
-    channel_class: type[SMTPChannel]
-
-    data_size_limit: int
-    enable_SMTPUTF8: bool
-    def __init__(
-        self,
-        localaddr: _Address,
-        remoteaddr: _Address,
-        data_size_limit: int = 33554432,
-        map: asyncore._MapType | None = None,
-        enable_SMTPUTF8: bool = False,
-        decode_data: bool = False,
-    ) -> None: ...
-    def handle_accepted(self, conn: socket.socket, addr: Any) -> None: ...
-    def process_message(
-        self, peer: _Address, mailfrom: str, rcpttos: list[str], data: bytes | str, **kwargs: Any
-    ) -> str | None: ...
-
-class DebuggingServer(SMTPServer): ...
-
-class PureProxy(SMTPServer):
-    def process_message(self, peer: _Address, mailfrom: str, rcpttos: list[str], data: bytes | str) -> str | None: ...  # type: ignore[override]
-
-if sys.version_info < (3, 11):
-    class MailmanProxy(PureProxy):
-        def process_message(self, peer: _Address, mailfrom: str, rcpttos: list[str], data: bytes | str) -> str | None: ...  # type: ignore[override]

jaclang/vendor/mypy/typeshed/stdlib/smtplib.pyi

@@ -1,204 +0,0 @@
-import sys
-from _socket import _Address as _SourceAddress
-from _typeshed import ReadableBuffer, SizedBuffer
-from collections.abc import Sequence
-from email.message import Message as _Message
-from re import Pattern
-from socket import socket
-from ssl import SSLContext
-from types import TracebackType
-from typing import Any, Protocol, overload
-from typing_extensions import Self, TypeAlias
-
-__all__ = [
-    "SMTPException",
-    "SMTPServerDisconnected",
-    "SMTPResponseException",
-    "SMTPSenderRefused",
-    "SMTPRecipientsRefused",
-    "SMTPDataError",
-    "SMTPConnectError",
-    "SMTPHeloError",
-    "SMTPAuthenticationError",
-    "quoteaddr",
-    "quotedata",
-    "SMTP",
-    "SMTP_SSL",
-    "SMTPNotSupportedError",
-]
-
-_Reply: TypeAlias = tuple[int, bytes]
-_SendErrs: TypeAlias = dict[str, _Reply]
-
-SMTP_PORT: int
-SMTP_SSL_PORT: int
-CRLF: str
-bCRLF: bytes
-
-OLDSTYLE_AUTH: Pattern[str]
-
-class SMTPException(OSError): ...
-class SMTPNotSupportedError(SMTPException): ...
-class SMTPServerDisconnected(SMTPException): ...
-
-class SMTPResponseException(SMTPException):
-    smtp_code: int
-    smtp_error: bytes | str
-    args: tuple[int, bytes | str] | tuple[int, bytes, str]
-    def __init__(self, code: int, msg: bytes | str) -> None: ...
-
-class SMTPSenderRefused(SMTPResponseException):
-    smtp_error: bytes
-    sender: str
-    args: tuple[int, bytes, str]
-    def __init__(self, code: int, msg: bytes, sender: str) -> None: ...
-
-class SMTPRecipientsRefused(SMTPException):
-    recipients: _SendErrs
-    args: tuple[_SendErrs]
-    def __init__(self, recipients: _SendErrs) -> None: ...
-
-class SMTPDataError(SMTPResponseException): ...
-class SMTPConnectError(SMTPResponseException): ...
-class SMTPHeloError(SMTPResponseException): ...
-class SMTPAuthenticationError(SMTPResponseException): ...
-
-def quoteaddr(addrstring: str) -> str: ...
-def quotedata(data: str) -> str: ...
-
-class _AuthObject(Protocol):
-    @overload
-    def __call__(self, challenge: None = None, /) -> str | None: ...
-    @overload
-    def __call__(self, challenge: bytes, /) -> str: ...
-
-class SMTP:
-    debuglevel: int
-    sock: socket | None
-    # Type of file should match what socket.makefile() returns
-    file: Any | None
-    helo_resp: bytes | None
-    ehlo_msg: str
-    ehlo_resp: bytes | None
-    does_esmtp: bool
-    default_port: int
-    timeout: float
-    esmtp_features: dict[str, str]
-    command_encoding: str
-    source_address: _SourceAddress | None
-    local_hostname: str
-    def __init__(
-        self,
-        host: str = "",
-        port: int = 0,
-        local_hostname: str | None = None,
-        timeout: float = ...,
-        source_address: _SourceAddress | None = None,
-    ) -> None: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
-    ) -> None: ...
-    def set_debuglevel(self, debuglevel: int) -> None: ...
-    def connect(self, host: str = "localhost", port: int = 0, source_address: _SourceAddress | None = None) -> _Reply: ...
-    def send(self, s: ReadableBuffer | str) -> None: ...
-    def putcmd(self, cmd: str, args: str = "") -> None: ...
-    def getreply(self) -> _Reply: ...
-    def docmd(self, cmd: str, args: str = "") -> _Reply: ...
-    def helo(self, name: str = "") -> _Reply: ...
-    def ehlo(self, name: str = "") -> _Reply: ...
-    def has_extn(self, opt: str) -> bool: ...
-    def help(self, args: str = "") -> bytes: ...
-    def rset(self) -> _Reply: ...
-    def noop(self) -> _Reply: ...
-    def mail(self, sender: str, options: Sequence[str] = ()) -> _Reply: ...
-    def rcpt(self, recip: str, options: Sequence[str] = ()) -> _Reply: ...
-    def data(self, msg: ReadableBuffer | str) -> _Reply: ...
-    def verify(self, address: str) -> _Reply: ...
-    vrfy = verify
-    def expn(self, address: str) -> _Reply: ...
-    def ehlo_or_helo_if_needed(self) -> None: ...
-    user: str
-    password: str
-    def auth(self, mechanism: str, authobject: _AuthObject, *, initial_response_ok: bool = True) -> _Reply: ...
-    @overload
-    def auth_cram_md5(self, challenge: None = None) -> None: ...
-    @overload
-    def auth_cram_md5(self, challenge: ReadableBuffer) -> str: ...
-    def auth_plain(self, challenge: ReadableBuffer | None = None) -> str: ...
-    def auth_login(self, challenge: ReadableBuffer | None = None) -> str: ...
-    def login(self, user: str, password: str, *, initial_response_ok: bool = True) -> _Reply: ...
-    if sys.version_info >= (3, 12):
-        def starttls(self, *, context: SSLContext | None = None) -> _Reply: ...
-    else:
-        def starttls(
-            self, keyfile: str | None = None, certfile: str | None = None, context: SSLContext | None = None
-        ) -> _Reply: ...
-
-    def sendmail(
-        self,
-        from_addr: str,
-        to_addrs: str | Sequence[str],
-        msg: SizedBuffer | str,
-        mail_options: Sequence[str] = (),
-        rcpt_options: Sequence[str] = (),
-    ) -> _SendErrs: ...
-    def send_message(
-        self,
-        msg: _Message,
-        from_addr: str | None = None,
-        to_addrs: str | Sequence[str] | None = None,
-        mail_options: Sequence[str] = (),
-        rcpt_options: Sequence[str] = (),
-    ) -> _SendErrs: ...
-    def close(self) -> None: ...
-    def quit(self) -> _Reply: ...
-
-class SMTP_SSL(SMTP):
-    keyfile: str | None
-    certfile: str | None
-    context: SSLContext
-    if sys.version_info >= (3, 12):
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 0,
-            local_hostname: str | None = None,
-            *,
-            timeout: float = ...,
-            source_address: _SourceAddress | None = None,
-            context: SSLContext | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 0,
-            local_hostname: str | None = None,
-            keyfile: str | None = None,
-            certfile: str | None = None,
-            timeout: float = ...,
-            source_address: _SourceAddress | None = None,
-            context: SSLContext | None = None,
-        ) -> None: ...
-
-LMTP_PORT: int
-
-class LMTP(SMTP):
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 2003,
-            local_hostname: str | None = None,
-            source_address: _SourceAddress | None = None,
-            timeout: float = ...,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 2003,
-            local_hostname: str | None = None,
-            source_address: _SourceAddress | None = None,
-        ) -> None: ...