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

mypy/typeshed/stdlib/signal.pyi

@@ -0,0 +1,189 @@
+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: ...
+
+        if sys.version_info >= (3, 10):
+            def sigtimedwait(__sigset: Iterable[int], __timeout: float) -> struct_siginfo | None: ...
+            def sigwaitinfo(__sigset: Iterable[int]) -> struct_siginfo: ...
+        else:
+            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: ...

mypy/typeshed/stdlib/site.pyi

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

mypy/typeshed/stdlib/smtpd.pyi

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

mypy/typeshed/stdlib/smtplib.pyi

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

mypy/typeshed/stdlib/sndhdr.pyi

@@ -0,0 +1,14 @@
+from _typeshed import StrOrBytesPath
+from typing import NamedTuple
+
+__all__ = ["what", "whathdr"]
+
+class SndHeaders(NamedTuple):
+    filetype: str
+    framerate: int
+    nchannels: int
+    nframes: int
+    sampwidth: int | str
+
+def what(filename: StrOrBytesPath) -> SndHeaders | None: ...
+def whathdr(filename: StrOrBytesPath) -> SndHeaders | None: ...