basedpyright 1.24.0 → 1.25.0

package/dist/typeshed-fallback/stdlib/asyncio/sslproto.pyi

@@ -50,32 +50,13 @@ if sys.version_info < (3, 11):
         _shutdown_cb: Callable[[], None] | None
         def __init__(self, context: ssl.SSLContext, server_side: bool, server_hostname: str | None = None) -> None: ...
         @property
-        def context(self) -> ssl.SSLContext:
-            """The SSL context passed to the constructor."""
-            ...
+        def context(self) -> ssl.SSLContext: ...
         @property
-        def ssl_object(self) -> ssl.SSLObject | None:
-            """
-            The internal ssl.SSLObject instance.
-
-            Return None if the pipe is not wrapped.
-            """
-            ...
+        def ssl_object(self) -> ssl.SSLObject | None: ...
         @property
-        def need_ssldata(self) -> bool:
-            """
-            Whether more record level data is needed to complete a handshake
-            that is currently in progress.
-            """
-            ...
+        def need_ssldata(self) -> bool: ...
         @property
-        def wrapped(self) -> bool:
-            """
-            Whether a security layer is currently in effect.
-
-            Return False during handshake.
-            """
-            ...
+        def wrapped(self) -> bool: ...
         def do_handshake(self, callback: Callable[[BaseException | None], object] | None = None) -> list[bytes]: ...
         def shutdown(self, callback: Callable[[], object] | None = None) -> list[bytes]: ...
         def feed_eof(self) -> None: ...

package/dist/typeshed-fallback/stdlib/asyncore.pyi

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

package/dist/typeshed-fallback/stdlib/audioop.pyi

@@ -1,95 +1,43 @@
-from typing_extensions import Buffer, TypeAlias
-
-_AdpcmState: TypeAlias = tuple[int, int]
-_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
-
-class error(Exception): ...
-
-def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes:
-    """Return a fragment which is the addition of the two samples passed as parameters."""
-    ...
-def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
-    """Decode an Intel/DVI ADPCM coded fragment to a linear fragment."""
-    ...
-def alaw2lin(fragment: Buffer, width: int, /) -> bytes:
-    """Convert sound fragments in a-LAW encoding to linearly encoded sound fragments."""
-    ...
-def avg(fragment: Buffer, width: int, /) -> int:
-    """Return the average over all samples in the fragment."""
-    ...
-def avgpp(fragment: Buffer, width: int, /) -> int:
-    """Return the average peak-peak value over all samples in the fragment."""
-    ...
-def bias(fragment: Buffer, width: int, bias: int, /) -> bytes:
-    """Return a fragment that is the original fragment with a bias added to each sample."""
-    ...
-def byteswap(fragment: Buffer, width: int, /) -> bytes:
-    """Convert big-endian samples to little-endian and vice versa."""
-    ...
-def cross(fragment: Buffer, width: int, /) -> int:
-    """Return the number of zero crossings in the fragment passed as an argument."""
-    ...
-def findfactor(fragment: Buffer, reference: Buffer, /) -> float:
-    """Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal."""
-    ...
-def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]:
-    """Try to match reference as well as possible to a portion of fragment."""
-    ...
-def findmax(fragment: Buffer, length: int, /) -> int:
-    """Search fragment for a slice of specified number of samples with maximum energy."""
-    ...
-def getsample(fragment: Buffer, width: int, index: int, /) -> int:
-    """Return the value of sample index from the fragment."""
-    ...
-def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
-    """Convert samples to 4 bit Intel/DVI ADPCM encoding."""
-    ...
-def lin2alaw(fragment: Buffer, width: int, /) -> bytes:
-    """Convert samples in the audio fragment to a-LAW encoding."""
-    ...
-def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes:
-    """Convert samples between 1-, 2-, 3- and 4-byte formats."""
-    ...
-def lin2ulaw(fragment: Buffer, width: int, /) -> bytes:
-    """Convert samples in the audio fragment to u-LAW encoding."""
-    ...
-def max(fragment: Buffer, width: int, /) -> int:
-    """Return the maximum of the absolute value of all samples in a fragment."""
-    ...
-def maxpp(fragment: Buffer, width: int, /) -> int:
-    """Return the maximum peak-peak value in the sound fragment."""
-    ...
-def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]:
-    """Return the minimum and maximum values of all samples in the sound fragment."""
-    ...
-def mul(fragment: Buffer, width: int, factor: float, /) -> bytes:
-    """Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor."""
-    ...
-def ratecv(
-    fragment: Buffer,
-    width: int,
-    nchannels: int,
-    inrate: int,
-    outrate: int,
-    state: _RatecvState | None,
-    weightA: int = 1,
-    weightB: int = 0,
-    /,
-) -> tuple[bytes, _RatecvState]:
-    """Convert the frame rate of the input fragment."""
-    ...
-def reverse(fragment: Buffer, width: int, /) -> bytes:
-    """Reverse the samples in a fragment and returns the modified fragment."""
-    ...
-def rms(fragment: Buffer, width: int, /) -> int:
-    """Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n)."""
-    ...
-def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
-    """Convert a stereo fragment to a mono fragment."""
-    ...
-def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
-    """Generate a stereo fragment from a mono fragment."""
-    ...
-def ulaw2lin(fragment: Buffer, width: int, /) -> bytes:
-    """Convert sound fragments in u-LAW encoding to linearly encoded sound fragments."""
-    ...
+from typing_extensions import Buffer, TypeAlias
+
+_AdpcmState: TypeAlias = tuple[int, int]
+_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
+
+class error(Exception): ...
+
+def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes: ...
+def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+def alaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
+def avg(fragment: Buffer, width: int, /) -> int: ...
+def avgpp(fragment: Buffer, width: int, /) -> int: ...
+def bias(fragment: Buffer, width: int, bias: int, /) -> bytes: ...
+def byteswap(fragment: Buffer, width: int, /) -> bytes: ...
+def cross(fragment: Buffer, width: int, /) -> int: ...
+def findfactor(fragment: Buffer, reference: Buffer, /) -> float: ...
+def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]: ...
+def findmax(fragment: Buffer, length: int, /) -> int: ...
+def getsample(fragment: Buffer, width: int, index: int, /) -> int: ...
+def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+def lin2alaw(fragment: Buffer, width: int, /) -> bytes: ...
+def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes: ...
+def lin2ulaw(fragment: Buffer, width: int, /) -> bytes: ...
+def max(fragment: Buffer, width: int, /) -> int: ...
+def maxpp(fragment: Buffer, width: int, /) -> int: ...
+def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]: ...
+def mul(fragment: Buffer, width: int, factor: float, /) -> bytes: ...
+def ratecv(
+    fragment: Buffer,
+    width: int,
+    nchannels: int,
+    inrate: int,
+    outrate: int,
+    state: _RatecvState | None,
+    weightA: int = 1,
+    weightB: int = 0,
+    /,
+) -> tuple[bytes, _RatecvState]: ...
+def reverse(fragment: Buffer, width: int, /) -> bytes: ...
+def rms(fragment: Buffer, width: int, /) -> int: ...
+def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+def ulaw2lin(fragment: Buffer, width: int, /) -> bytes: ...

package/dist/typeshed-fallback/stdlib/binascii.pyi

@@ -27,9 +27,7 @@ if sys.version_info >= (3, 11):
         ...
 
 else:
-    def a2b_base64(data: _AsciiBuffer, /) -> bytes:
-        """Decode a line of base64 data."""
-        ...
+    def a2b_base64(data: _AsciiBuffer, /) -> bytes: ...
 
 def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes:
     """Base64-code line of data."""
@@ -48,18 +46,10 @@ def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, h
     ...
 
 if sys.version_info < (3, 11):
-    def a2b_hqx(data: _AsciiBuffer, /) -> bytes:
-        """Decode .hqx coding."""
-        ...
-    def rledecode_hqx(data: ReadableBuffer, /) -> bytes:
-        """Decode hexbin RLE-coded string."""
-        ...
-    def rlecode_hqx(data: ReadableBuffer, /) -> bytes:
-        """Binhex RLE-code binary data."""
-        ...
-    def b2a_hqx(data: ReadableBuffer, /) -> bytes:
-        """Encode .hqx data."""
-        ...
+    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:
     """Compute CRC-CCITT incrementally."""

package/dist/typeshed-fallback/stdlib/binhex.pyi

@@ -1,45 +1,45 @@
-from _typeshed import SizedBuffer
-from typing import IO, Any, Final
-from typing_extensions import TypeAlias
-
-__all__ = ["binhex", "hexbin", "Error"]
-
-class Error(Exception): ...
-
-REASONABLY_LARGE: Final = 32768
-LINELEN: Final = 64
-RUNCHAR: Final = b"\x90"
-
-class FInfo:
-    Type: str
-    Creator: str
-    Flags: int
-
-_FileInfoTuple: TypeAlias = tuple[str, FInfo, int, int]
-_FileHandleUnion: TypeAlias = str | IO[bytes]
-
-def getfileinfo(name: str) -> _FileInfoTuple: ...
-
-class openrsrc:
-    def __init__(self, *args: Any) -> None: ...
-    def read(self, *args: Any) -> bytes: ...
-    def write(self, *args: Any) -> None: ...
-    def close(self) -> None: ...
-
-class BinHex:
-    def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ...
-    def write(self, data: SizedBuffer) -> None: ...
-    def close_data(self) -> None: ...
-    def write_rsrc(self, data: SizedBuffer) -> None: ...
-    def close(self) -> None: ...
-
-def binhex(inp: str, out: str) -> None: ...
-
-class HexBin:
-    def __init__(self, ifp: _FileHandleUnion) -> None: ...
-    def read(self, *n: int) -> bytes: ...
-    def close_data(self) -> None: ...
-    def read_rsrc(self, *n: int) -> bytes: ...
-    def close(self) -> None: ...
-
-def hexbin(inp: str, out: str) -> None: ...
+from _typeshed import SizedBuffer
+from typing import IO, Any, Final
+from typing_extensions import TypeAlias
+
+__all__ = ["binhex", "hexbin", "Error"]
+
+class Error(Exception): ...
+
+REASONABLY_LARGE: Final = 32768
+LINELEN: Final = 64
+RUNCHAR: Final = b"\x90"
+
+class FInfo:
+    Type: str
+    Creator: str
+    Flags: int
+
+_FileInfoTuple: TypeAlias = tuple[str, FInfo, int, int]
+_FileHandleUnion: TypeAlias = str | IO[bytes]
+
+def getfileinfo(name: str) -> _FileInfoTuple: ...
+
+class openrsrc:
+    def __init__(self, *args: Any) -> None: ...
+    def read(self, *args: Any) -> bytes: ...
+    def write(self, *args: Any) -> None: ...
+    def close(self) -> None: ...
+
+class BinHex:
+    def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ...
+    def write(self, data: SizedBuffer) -> None: ...
+    def close_data(self) -> None: ...
+    def write_rsrc(self, data: SizedBuffer) -> None: ...
+    def close(self) -> None: ...
+
+def binhex(inp: str, out: str) -> None: ...
+
+class HexBin:
+    def __init__(self, ifp: _FileHandleUnion) -> None: ...
+    def read(self, *n: int) -> bytes: ...
+    def close_data(self) -> None: ...
+    def read_rsrc(self, *n: int) -> bytes: ...
+    def close(self) -> None: ...
+
+def hexbin(inp: str, out: str) -> None: ...

package/dist/typeshed-fallback/stdlib/builtins.pyi

@@ -515,25 +515,7 @@ class int:
             """
             ...
     else:
-        def to_bytes(self, length: SupportsIndex, byteorder: Literal["little", "big"], *, signed: bool = False) -> bytes:
-            """
-            Return an array of bytes representing an integer.
-
-            length
-              Length of bytes object to use.  An OverflowError is raised if the
-              integer is not representable with the given number of bytes.
-            byteorder
-              The byte order used to represent the integer.  If byteorder is 'big',
-              the most significant byte is at the beginning of the byte array.  If
-              byteorder is 'little', the most significant byte is at the end of the
-              byte array.  To request the native byte order of the host system, use
-              `sys.byteorder' as the byte order value.
-            signed
-              Determines whether two's complement is used to represent the integer.
-              If signed is False and a negative integer is given, an OverflowError
-              is raised.
-            """
-            ...
+        def to_bytes(self, length: SupportsIndex, byteorder: Literal["little", "big"], *, signed: bool = False) -> bytes: ...
         @classmethod
         def from_bytes(
             cls,
@@ -541,25 +523,7 @@ class int:
             byteorder: Literal["little", "big"],
             *,
             signed: bool = False,
-        ) -> Self:
-            """
-            Return the integer represented by the given array of bytes.
-
-            bytes
-              Holds the array of bytes to convert.  The argument must either
-              support the buffer protocol or be an iterable object producing bytes.
-              Bytes and bytearray are examples of built-in objects that support the
-              buffer protocol.
-            byteorder
-              The byte order used to represent the integer.  If byteorder is 'big',
-              the most significant byte is at the beginning of the byte array.  If
-              byteorder is 'little', the most significant byte is at the end of the
-              byte array.  To request the native byte order of the host system, use
-              `sys.byteorder' as the byte order value.
-            signed
-              Indicates whether two's complement is used to represent the integer.
-            """
-            ...
+        ) -> Self: ...
 
     if sys.version_info >= (3, 12):
         def is_integer(self) -> Literal[True]:
@@ -1370,31 +1334,9 @@ class str(Sequence[str]):
         @overload
         def replace(
             self: LiteralString, old: LiteralString, new: LiteralString, count: SupportsIndex = -1, /
-        ) -> LiteralString:
-            """
-            Return a copy with all occurrences of substring old replaced by new.
-
-              count
-                Maximum number of occurrences to replace.
-                -1 (the default value) means replace all occurrences.
-
-            If the optional argument count is given, only the first count occurrences are
-            replaced.
-            """
-            ...
+        ) -> LiteralString: ...
         @overload
-        def replace(self, old: str, new: str, count: SupportsIndex = -1, /) -> str:
-            """
-            Return a copy with all occurrences of substring old replaced by new.
-
-              count
-                Maximum number of occurrences to replace.
-                -1 (the default value) means replace all occurrences.
-
-            If the optional argument count is given, only the first count occurrences are
-            replaced.
-            """
-            ...
+        def replace(self, old: str, new: str, count: SupportsIndex = -1, /) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
         @overload
         def removeprefix(self: LiteralString, prefix: LiteralString, /) -> LiteralString:
@@ -3055,15 +2997,7 @@ class memoryview(Sequence[_I]):
             """
             ...
     else:
-        def tobytes(self, order: Literal["C", "F", "A"] | None = None) -> bytes:
-            """
-            Return the data in the buffer as a byte string. Order can be {'C', 'F', 'A'}.
-            When order is 'C' or 'F', the data of the original array is converted to C or
-            Fortran order. For contiguous views, 'A' returns an exact copy of the physical
-            memory. In particular, in-memory Fortran order is preserved. For non-contiguous
-            views, the data is converted to C first. order=None is the same as order='C'.
-            """
-            ...
+        def tobytes(self, order: Literal["C", "F", "A"] | None = None) -> bytes: ...
 
     def tolist(self) -> list[int]:
         """Return the data in the buffer as a list of elements."""
@@ -4242,17 +4176,7 @@ else:
         globals: dict[str, Any] | None = None,
         locals: Mapping[str, object] | None = None,
         /,
-    ) -> Any:
-        """
-        Evaluate the given source in the context of globals and locals.
-
-        The source may be a string representing a Python expression
-        or a code object as returned by compile().
-        The globals must be a dictionary and locals can be any mapping,
-        defaulting to the current globals and locals.
-        If only globals is given, locals defaults to it.
-        """
-        ...
+    ) -> Any: ...
 
 # Comment above regarding `eval` applies to `exec` as well
 if sys.version_info >= (3, 13):
@@ -4285,19 +4209,7 @@ elif sys.version_info >= (3, 11):
         /,
         *,
         closure: tuple[CellType, ...] | None = None,
-    ) -> None:
-        """
-        Execute the given source in the context of globals and locals.
-
-        The source may be a string representing one or more Python statements
-        or a code object as returned by compile().
-        The globals must be a dictionary and locals can be any mapping,
-        defaulting to the current globals and locals.
-        If only globals is given, locals defaults to it.
-        The closure must be a tuple of cellvars, and can only be used
-        when source is a code object requiring exactly that many cellvars.
-        """
-        ...
+    ) -> None: ...
 
 else:
     def exec(
@@ -4305,17 +4217,7 @@ else:
         globals: dict[str, Any] | None = None,
         locals: Mapping[str, object] | None = None,
         /,
-    ) -> None:
-        """
-        Execute the given source in the context of globals and locals.
-
-        The source may be a string representing one or more Python statements
-        or a code object as returned by compile().
-        The globals must be a dictionary and locals can be any mapping,
-        defaulting to the current globals and locals.
-        If only globals is given, locals defaults to it.
-        """
-        ...
+    ) -> None: ...
 
 def exit(code: sys._ExitCode = None) -> NoReturn: ...