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

mypy/typeshed/stdlib/asyncio/unix_events.pyi

@@ -0,0 +1,173 @@
+import sys
+import types
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable
+from typing import Literal
+from typing_extensions import Self, TypeVarTuple, Unpack, deprecated
+
+from .events import AbstractEventLoop, BaseDefaultEventLoopPolicy
+from .selector_events import BaseSelectorEventLoop
+
+_Ts = TypeVarTuple("_Ts")
+
+# This is also technically not available on Win,
+# but other parts of typeshed need this definition.
+# So, it is special cased.
+if sys.version_info >= (3, 12):
+    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+    class AbstractChildWatcher:
+        @abstractmethod
+        def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+        @abstractmethod
+        def remove_child_handler(self, pid: int) -> bool: ...
+        @abstractmethod
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        @abstractmethod
+        def close(self) -> None: ...
+        @abstractmethod
+        def __enter__(self) -> Self: ...
+        @abstractmethod
+        def __exit__(
+            self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+        ) -> None: ...
+        @abstractmethod
+        def is_active(self) -> bool: ...
+
+else:
+    class AbstractChildWatcher:
+        @abstractmethod
+        def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+        @abstractmethod
+        def remove_child_handler(self, pid: int) -> bool: ...
+        @abstractmethod
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        @abstractmethod
+        def close(self) -> None: ...
+        @abstractmethod
+        def __enter__(self) -> Self: ...
+        @abstractmethod
+        def __exit__(
+            self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+        ) -> None: ...
+        @abstractmethod
+        def is_active(self) -> bool: ...
+
+if sys.platform != "win32":
+    if sys.version_info >= (3, 9):
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "PidfdChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
+    else:
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
+
+    # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+    # See discussion in #7412
+    class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+        def close(self) -> None: ...
+        def is_active(self) -> bool: ...
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class SafeChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class FastChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+    else:
+        class SafeChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+
+        class FastChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+
+    class _UnixSelectorEventLoop(BaseSelectorEventLoop): ...
+
+    class _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy):
+        if sys.version_info >= (3, 12):
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+        else:
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+    SelectorEventLoop = _UnixSelectorEventLoop
+
+    DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
+
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class MultiLoopChildWatcher(AbstractChildWatcher):
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+            ) -> None: ...
+            def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+    else:
+        class MultiLoopChildWatcher(AbstractChildWatcher):
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+            ) -> None: ...
+            def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    class ThreadedChildWatcher(AbstractChildWatcher):
+        def is_active(self) -> Literal[True]: ...
+        def close(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+        ) -> None: ...
+        def __del__(self) -> None: ...
+        def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+        def remove_child_handler(self, pid: int) -> bool: ...
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    if sys.version_info >= (3, 9):
+        class PidfdChildWatcher(AbstractChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+            ) -> None: ...
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            def add_child_handler(self, pid: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...

mypy/typeshed/stdlib/asyncio/windows_events.pyi

@@ -0,0 +1,83 @@
+import socket
+import sys
+from _typeshed import Incomplete, ReadableBuffer, WriteableBuffer
+from collections.abc import Callable
+from typing import IO, Any, ClassVar, Literal, NoReturn
+
+from . import events, futures, proactor_events, selector_events, streams, windows_utils
+
+if sys.platform == "win32":
+    __all__ = (
+        "SelectorEventLoop",
+        "ProactorEventLoop",
+        "IocpProactor",
+        "DefaultEventLoopPolicy",
+        "WindowsSelectorEventLoopPolicy",
+        "WindowsProactorEventLoopPolicy",
+    )
+
+    NULL: Literal[0]
+    INFINITE: Literal[0xFFFFFFFF]
+    ERROR_CONNECTION_REFUSED: Literal[1225]
+    ERROR_CONNECTION_ABORTED: Literal[1236]
+    CONNECT_PIPE_INIT_DELAY: float
+    CONNECT_PIPE_MAX_DELAY: float
+
+    class PipeServer:
+        def __init__(self, address: str) -> None: ...
+        def __del__(self) -> None: ...
+        def closed(self) -> bool: ...
+        def close(self) -> None: ...
+
+    class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop): ...
+
+    class ProactorEventLoop(proactor_events.BaseProactorEventLoop):
+        def __init__(self, proactor: IocpProactor | None = None) -> None: ...
+        async def create_pipe_connection(
+            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
+        ) -> tuple[proactor_events._ProactorDuplexPipeTransport, streams.StreamReaderProtocol]: ...
+        async def start_serving_pipe(
+            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
+        ) -> list[PipeServer]: ...
+
+    class IocpProactor:
+        def __init__(self, concurrency: int = 0xFFFFFFFF) -> None: ...
+        def __del__(self) -> None: ...
+        def set_loop(self, loop: events.AbstractEventLoop) -> None: ...
+        def select(self, timeout: int | None = None) -> list[futures.Future[Any]]: ...
+        def recv(self, conn: socket.socket, nbytes: int, flags: int = 0) -> futures.Future[bytes]: ...
+        def recv_into(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
+        def recvfrom(
+            self, conn: socket.socket, nbytes: int, flags: int = 0
+        ) -> futures.Future[tuple[bytes, socket._RetAddress]]: ...
+        def sendto(
+            self, conn: socket.socket, buf: ReadableBuffer, flags: int = 0, addr: socket._Address | None = None
+        ) -> futures.Future[int]: ...
+        def send(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
+        def accept(self, listener: socket.socket) -> futures.Future[Any]: ...
+        def connect(
+            self,
+            conn: socket.socket,
+            address: tuple[Incomplete, Incomplete] | tuple[Incomplete, Incomplete, Incomplete, Incomplete],
+        ) -> futures.Future[Any]: ...
+        def sendfile(self, sock: socket.socket, file: IO[bytes], offset: int, count: int) -> futures.Future[Any]: ...
+        def accept_pipe(self, pipe: socket.socket) -> futures.Future[Any]: ...
+        async def connect_pipe(self, address: str) -> windows_utils.PipeHandle: ...
+        def wait_for_handle(self, handle: windows_utils.PipeHandle, timeout: int | None = None) -> bool: ...
+        def close(self) -> None: ...
+        if sys.version_info >= (3, 11):
+            def recvfrom_into(
+                self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
+            ) -> futures.Future[tuple[int, socket._RetAddress]]: ...
+    SelectorEventLoop = _WindowsSelectorEventLoop
+
+    class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+        _loop_factory: ClassVar[type[SelectorEventLoop]]
+        def get_child_watcher(self) -> NoReturn: ...
+        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
+    class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+        _loop_factory: ClassVar[type[ProactorEventLoop]]
+        def get_child_watcher(self) -> NoReturn: ...
+        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+    DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy

mypy/typeshed/stdlib/asyncio/windows_utils.pyi

@@ -0,0 +1,49 @@
+import subprocess
+import sys
+from collections.abc import Callable
+from types import TracebackType
+from typing import Any, AnyStr, Literal
+from typing_extensions import Self
+
+if sys.platform == "win32":
+    __all__ = ("pipe", "Popen", "PIPE", "PipeHandle")
+
+    BUFSIZE: Literal[8192]
+    PIPE = subprocess.PIPE
+    STDOUT = subprocess.STDOUT
+    def pipe(*, duplex: bool = False, overlapped: tuple[bool, bool] = (True, True), bufsize: int = 8192) -> tuple[int, int]: ...
+
+    class PipeHandle:
+        def __init__(self, handle: int) -> None: ...
+        def __del__(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+        @property
+        def handle(self) -> int: ...
+        def fileno(self) -> int: ...
+        def close(self, *, CloseHandle: Callable[[int], object] = ...) -> None: ...
+
+    class Popen(subprocess.Popen[AnyStr]):
+        stdin: PipeHandle | None  # type: ignore[assignment]
+        stdout: PipeHandle | None  # type: ignore[assignment]
+        stderr: PipeHandle | None  # type: ignore[assignment]
+        # For simplicity we omit the full overloaded __new__ signature of
+        # subprocess.Popen. The arguments are mostly the same, but
+        # subprocess.Popen takes other positional-or-keyword arguments before
+        # stdin.
+        def __new__(
+            cls,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = ...,
+            stdout: subprocess._FILE | None = ...,
+            stderr: subprocess._FILE | None = ...,
+            **kwds: Any,
+        ) -> Self: ...
+        def __init__(
+            self,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = None,
+            stdout: subprocess._FILE | None = None,
+            stderr: subprocess._FILE | None = None,
+            **kwds: Any,
+        ) -> None: ...

mypy/typeshed/stdlib/asyncore.pyi

@@ -0,0 +1,90 @@
+import sys
+from _typeshed import FileDescriptorLike, ReadableBuffer
+from socket import socket
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+# cyclic dependence with asynchat
+_MapType: TypeAlias = dict[int, Any]
+_Socket: TypeAlias = socket
+
+socket_map: _MapType  # undocumented
+
+class ExitNow(Exception): ...
+
+def read(obj: Any) -> None: ...
+def write(obj: Any) -> None: ...
+def readwrite(obj: Any, flags: int) -> None: ...
+def poll(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+def poll2(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+
+poll3 = poll2
+
+def loop(timeout: float = 30.0, use_poll: bool = False, map: _MapType | None = None, count: int | None = None) -> None: ...
+
+# Not really subclass of socket.socket; it's only delegation.
+# It is not covariant to it.
+class dispatcher:
+    debug: bool
+    connected: bool
+    accepting: bool
+    connecting: bool
+    closing: bool
+    ignore_log_types: frozenset[str]
+    socket: _Socket | None
+    def __init__(self, sock: _Socket | None = None, map: _MapType | None = None) -> None: ...
+    def add_channel(self, map: _MapType | None = None) -> None: ...
+    def del_channel(self, map: _MapType | None = None) -> None: ...
+    def create_socket(self, family: int = ..., type: int = ...) -> None: ...
+    def set_socket(self, sock: _Socket, map: _MapType | None = None) -> None: ...
+    def set_reuse_addr(self) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def listen(self, num: int) -> None: ...
+    def bind(self, addr: tuple[Any, ...] | str) -> None: ...
+    def connect(self, address: tuple[Any, ...] | str) -> None: ...
+    def accept(self) -> tuple[_Socket, Any] | None: ...
+    def send(self, data: ReadableBuffer) -> int: ...
+    def recv(self, buffer_size: int) -> bytes: ...
+    def close(self) -> None: ...
+    def log(self, message: Any) -> None: ...
+    def log_info(self, message: Any, type: str = "info") -> None: ...
+    def handle_read_event(self) -> None: ...
+    def handle_connect_event(self) -> None: ...
+    def handle_write_event(self) -> None: ...
+    def handle_expt_event(self) -> None: ...
+    def handle_error(self) -> None: ...
+    def handle_expt(self) -> None: ...
+    def handle_read(self) -> None: ...
+    def handle_write(self) -> None: ...
+    def handle_connect(self) -> None: ...
+    def handle_accept(self) -> None: ...
+    def handle_close(self) -> None: ...
+
+class dispatcher_with_send(dispatcher):
+    def initiate_send(self) -> None: ...
+    # incompatible signature:
+    # def send(self, data: bytes) -> int | None: ...
+
+def compact_traceback() -> tuple[tuple[str, str, str], type, type, str]: ...
+def close_all(map: _MapType | None = None, ignore_all: bool = False) -> None: ...
+
+if sys.platform != "win32":
+    class file_wrapper:
+        fd: int
+        def __init__(self, fd: int) -> None: ...
+        def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def send(self, data: bytes, flags: int = ...) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: None = None) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+        def read(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def write(self, data: bytes, flags: int = ...) -> int: ...
+        def close(self) -> None: ...
+        def fileno(self) -> int: ...
+        def __del__(self) -> None: ...
+
+    class file_dispatcher(dispatcher):
+        def __init__(self, fd: FileDescriptorLike, map: _MapType | None = None) -> None: ...
+        def set_file(self, fd: int) -> None: ...

mypy/typeshed/stdlib/atexit.pyi

@@ -0,0 +1,12 @@
+from collections.abc import Callable
+from typing import TypeVar
+from typing_extensions import ParamSpec
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+
+def _clear() -> None: ...
+def _ncallbacks() -> int: ...
+def _run_exitfuncs() -> None: ...
+def register(func: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
+def unregister(func: Callable[..., object]) -> None: ...

mypy/typeshed/stdlib/audioop.pyi

@@ -0,0 +1,42 @@
+from typing_extensions import TypeAlias
+
+_AdpcmState: TypeAlias = tuple[int, int]
+_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
+
+class error(Exception): ...
+
+def add(__fragment1: bytes, __fragment2: bytes, __width: int) -> bytes: ...
+def adpcm2lin(__fragment: bytes, __width: int, __state: _AdpcmState | None) -> tuple[bytes, _AdpcmState]: ...
+def alaw2lin(__fragment: bytes, __width: int) -> bytes: ...
+def avg(__fragment: bytes, __width: int) -> int: ...
+def avgpp(__fragment: bytes, __width: int) -> int: ...
+def bias(__fragment: bytes, __width: int, __bias: int) -> bytes: ...
+def byteswap(__fragment: bytes, __width: int) -> bytes: ...
+def cross(__fragment: bytes, __width: int) -> int: ...
+def findfactor(__fragment: bytes, __reference: bytes) -> float: ...
+def findfit(__fragment: bytes, __reference: bytes) -> tuple[int, float]: ...
+def findmax(__fragment: bytes, __length: int) -> int: ...
+def getsample(__fragment: bytes, __width: int, __index: int) -> int: ...
+def lin2adpcm(__fragment: bytes, __width: int, __state: _AdpcmState | None) -> tuple[bytes, _AdpcmState]: ...
+def lin2alaw(__fragment: bytes, __width: int) -> bytes: ...
+def lin2lin(__fragment: bytes, __width: int, __newwidth: int) -> bytes: ...
+def lin2ulaw(__fragment: bytes, __width: int) -> bytes: ...
+def max(__fragment: bytes, __width: int) -> int: ...
+def maxpp(__fragment: bytes, __width: int) -> int: ...
+def minmax(__fragment: bytes, __width: int) -> tuple[int, int]: ...
+def mul(__fragment: bytes, __width: int, __factor: float) -> bytes: ...
+def ratecv(
+    __fragment: bytes,
+    __width: int,
+    __nchannels: int,
+    __inrate: int,
+    __outrate: int,
+    __state: _RatecvState | None,
+    __weightA: int = 1,
+    __weightB: int = 0,
+) -> tuple[bytes, _RatecvState]: ...
+def reverse(__fragment: bytes, __width: int) -> bytes: ...
+def rms(__fragment: bytes, __width: int) -> int: ...
+def tomono(__fragment: bytes, __width: int, __lfactor: float, __rfactor: float) -> bytes: ...
+def tostereo(__fragment: bytes, __width: int, __lfactor: float, __rfactor: float) -> bytes: ...
+def ulaw2lin(__fragment: bytes, __width: int) -> bytes: ...

mypy/typeshed/stdlib/base64.pyi

@@ -0,0 +1,59 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import IO
+
+__all__ = [
+    "encode",
+    "decode",
+    "encodebytes",
+    "decodebytes",
+    "b64encode",
+    "b64decode",
+    "b32encode",
+    "b32decode",
+    "b16encode",
+    "b16decode",
+    "b85encode",
+    "b85decode",
+    "a85encode",
+    "a85decode",
+    "standard_b64encode",
+    "standard_b64decode",
+    "urlsafe_b64encode",
+    "urlsafe_b64decode",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["b32hexencode", "b32hexdecode"]
+
+def b64encode(s: ReadableBuffer, altchars: ReadableBuffer | None = None) -> bytes: ...
+def b64decode(s: str | ReadableBuffer, altchars: str | ReadableBuffer | None = None, validate: bool = False) -> bytes: ...
+def standard_b64encode(s: ReadableBuffer) -> bytes: ...
+def standard_b64decode(s: str | ReadableBuffer) -> bytes: ...
+def urlsafe_b64encode(s: ReadableBuffer) -> bytes: ...
+def urlsafe_b64decode(s: str | ReadableBuffer) -> bytes: ...
+def b32encode(s: ReadableBuffer) -> bytes: ...
+def b32decode(s: str | ReadableBuffer, casefold: bool = False, map01: str | ReadableBuffer | None = None) -> bytes: ...
+def b16encode(s: ReadableBuffer) -> bytes: ...
+def b16decode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 10):
+    def b32hexencode(s: ReadableBuffer) -> bytes: ...
+    def b32hexdecode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
+
+def a85encode(
+    b: ReadableBuffer, *, foldspaces: bool = False, wrapcol: int = 0, pad: bool = False, adobe: bool = False
+) -> bytes: ...
+def a85decode(
+    b: str | ReadableBuffer, *, foldspaces: bool = False, adobe: bool = False, ignorechars: bytearray | bytes = b" \t\n\r\x0b"
+) -> bytes: ...
+def b85encode(b: ReadableBuffer, pad: bool = False) -> bytes: ...
+def b85decode(b: str | ReadableBuffer) -> bytes: ...
+def decode(input: IO[bytes], output: IO[bytes]) -> None: ...
+def encode(input: IO[bytes], output: IO[bytes]) -> None: ...
+def encodebytes(s: ReadableBuffer) -> bytes: ...
+def decodebytes(s: ReadableBuffer) -> bytes: ...
+
+if sys.version_info < (3, 9):
+    def encodestring(s: ReadableBuffer) -> bytes: ...
+    def decodestring(s: ReadableBuffer) -> bytes: ...

mypy/typeshed/stdlib/bdb.pyi

@@ -0,0 +1,102 @@
+import sys
+from _typeshed import ExcInfo, TraceFunction
+from collections.abc import Callable, Iterable, Mapping
+from types import CodeType, FrameType, TracebackType
+from typing import IO, Any, Literal, SupportsInt, TypeVar
+from typing_extensions import ParamSpec
+
+__all__ = ["BdbQuit", "Bdb", "Breakpoint"]
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+
+GENERATOR_AND_COROUTINE_FLAGS: Literal[672]
+
+class BdbQuit(Exception): ...
+
+class Bdb:
+    skip: set[str] | None
+    breaks: dict[str, list[int]]
+    fncache: dict[str, str]
+    frame_returning: FrameType | None
+    botframe: FrameType | None
+    quitting: bool
+    stopframe: FrameType | None
+    returnframe: FrameType | None
+    stoplineno: int
+    def __init__(self, skip: Iterable[str] | None = None) -> None: ...
+    def canonic(self, filename: str) -> str: ...
+    def reset(self) -> None: ...
+    def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> TraceFunction: ...
+    def dispatch_line(self, frame: FrameType) -> TraceFunction: ...
+    def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
+    def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
+    def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
+    def is_skipped_module(self, module_name: str) -> bool: ...
+    def stop_here(self, frame: FrameType) -> bool: ...
+    def break_here(self, frame: FrameType) -> bool: ...
+    def do_clear(self, arg: Any) -> bool | None: ...
+    def break_anywhere(self, frame: FrameType) -> bool: ...
+    def user_call(self, frame: FrameType, argument_list: None) -> None: ...
+    def user_line(self, frame: FrameType) -> None: ...
+    def user_return(self, frame: FrameType, return_value: Any) -> None: ...
+    def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
+    def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
+    def set_step(self) -> None: ...
+    def set_next(self, frame: FrameType) -> None: ...
+    def set_return(self, frame: FrameType) -> None: ...
+    def set_trace(self, frame: FrameType | None = None) -> None: ...
+    def set_continue(self) -> None: ...
+    def set_quit(self) -> None: ...
+    def set_break(
+        self, filename: str, lineno: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
+    ) -> str | None: ...
+    def clear_break(self, filename: str, lineno: int) -> str | None: ...
+    def clear_bpbynumber(self, arg: SupportsInt) -> str | None: ...
+    def clear_all_file_breaks(self, filename: str) -> str | None: ...
+    def clear_all_breaks(self) -> str | None: ...
+    def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint: ...
+    def get_break(self, filename: str, lineno: int) -> bool: ...
+    def get_breaks(self, filename: str, lineno: int) -> list[Breakpoint]: ...
+    def get_file_breaks(self, filename: str) -> list[Breakpoint]: ...
+    def get_all_breaks(self) -> list[Breakpoint]: ...
+    def get_stack(self, f: FrameType | None, t: TracebackType | None) -> tuple[list[tuple[FrameType, int]], int]: ...
+    def format_stack_entry(self, frame_lineno: int, lprefix: str = ": ") -> str: ...
+    def run(
+        self, cmd: str | CodeType, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None
+    ) -> None: ...
+    def runeval(self, expr: str, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None) -> None: ...
+    def runctx(self, cmd: str | CodeType, globals: dict[str, Any] | None, locals: Mapping[str, Any] | None) -> None: ...
+    def runcall(self, __func: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
+
+class Breakpoint:
+    next: int
+    bplist: dict[tuple[str, int], list[Breakpoint]]
+    bpbynumber: list[Breakpoint | None]
+
+    funcname: str | None
+    func_first_executable_line: int | None
+    file: str
+    line: int
+    temporary: bool
+    cond: str | None
+    enabled: bool
+    ignore: int
+    hits: int
+    number: int
+    def __init__(
+        self, file: str, line: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
+    ) -> None: ...
+    if sys.version_info >= (3, 11):
+        @staticmethod
+        def clearBreakpoints() -> None: ...
+
+    def deleteMe(self) -> None: ...
+    def enable(self) -> None: ...
+    def disable(self) -> None: ...
+    def bpprint(self, out: IO[str] | None = None) -> None: ...
+    def bpformat(self) -> str: ...
+
+def checkfuncname(b: Breakpoint, frame: FrameType) -> bool: ...
+def effective(file: str, line: int, frame: FrameType) -> tuple[Breakpoint, bool] | tuple[None, None]: ...
+def set_trace() -> None: ...

mypy/typeshed/stdlib/binascii.pyi

@@ -0,0 +1,36 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing_extensions import TypeAlias
+
+# Many functions in binascii accept buffer objects
+# or ASCII-only strings.
+_AsciiBuffer: TypeAlias = str | ReadableBuffer
+
+def a2b_uu(__data: _AsciiBuffer) -> bytes: ...
+def b2a_uu(__data: ReadableBuffer, *, backtick: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 11):
+    def a2b_base64(__data: _AsciiBuffer, *, strict_mode: bool = False) -> bytes: ...
+
+else:
+    def a2b_base64(__data: _AsciiBuffer) -> bytes: ...
+
+def b2a_base64(__data: ReadableBuffer, *, newline: bool = True) -> bytes: ...
+def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes: ...
+def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes: ...
+
+if sys.version_info < (3, 11):
+    def a2b_hqx(__data: _AsciiBuffer) -> bytes: ...
+    def rledecode_hqx(__data: ReadableBuffer) -> bytes: ...
+    def rlecode_hqx(__data: ReadableBuffer) -> bytes: ...
+    def b2a_hqx(__data: ReadableBuffer) -> bytes: ...
+
+def crc_hqx(__data: ReadableBuffer, __crc: int) -> int: ...
+def crc32(__data: ReadableBuffer, __crc: int = 0) -> int: ...
+def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
+def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
+def a2b_hex(__hexstr: _AsciiBuffer) -> bytes: ...
+def unhexlify(__hexstr: _AsciiBuffer) -> bytes: ...
+
+class Error(ValueError): ...
+class Incomplete(Exception): ...