Sync typeshed

Source commit:
python/typeshed@8036bbd

mypy/typeshed/stdlib/_codecs.pyi

@@ -1,5 +1,6 @@
 import codecs
 import sys
+from _typeshed import ReadableBuffer
 from collections.abc import Callable
 from typing import overload
 from typing_extensions import Literal, TypeAlias
@@ -44,13 +45,13 @@ _BytesToBytesEncoding: TypeAlias = Literal[
 _StrToStrEncoding: TypeAlias = Literal["rot13", "rot_13"]
 
 @overload
-def encode(obj: bytes, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...
+def encode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...
 @overload
 def encode(obj: str, encoding: _StrToStrEncoding, errors: str = ...) -> str: ...  # type: ignore[misc]
 @overload
 def encode(obj: str, encoding: str = ..., errors: str = ...) -> bytes: ...
 @overload
-def decode(obj: bytes, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...  # type: ignore[misc]
+def decode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...  # type: ignore[misc]
 @overload
 def decode(obj: str, encoding: _StrToStrEncoding, errors: str = ...) -> str: ...
 
@@ -64,66 +65,72 @@ def decode(
 @overload
 def decode(obj: str, encoding: Literal["hex", "hex_codec"], errors: str = ...) -> bytes: ...
 @overload
-def decode(obj: bytes, encoding: str = ..., errors: str = ...) -> str: ...
+def decode(obj: ReadableBuffer, encoding: str = ..., errors: str = ...) -> str: ...
 def lookup(__encoding: str) -> codecs.CodecInfo: ...
 def charmap_build(__map: str) -> _CharMap: ...
-def ascii_decode(__data: bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+def ascii_decode(__data: ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 def ascii_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def charmap_decode(__data: bytes, __errors: str | None = ..., __mapping: _CharMap | None = ...) -> tuple[str, int]: ...
+def charmap_decode(__data: ReadableBuffer, __errors: str | None = ..., __mapping: _CharMap | None = ...) -> tuple[str, int]: ...
 def charmap_encode(__str: str, __errors: str | None = ..., __mapping: _CharMap | None = ...) -> tuple[bytes, int]: ...
-def escape_decode(__data: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+def escape_decode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 def escape_encode(__data: bytes, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def latin_1_decode(__data: bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+def latin_1_decode(__data: ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 def latin_1_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.version_info >= (3, 9):
-    def raw_unicode_escape_decode(__data: str | bytes, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
+    def raw_unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = ..., __final: bool = ...
+    ) -> tuple[str, int]: ...
 
 else:
-    def raw_unicode_escape_decode(__data: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+    def raw_unicode_escape_decode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 
 def raw_unicode_escape_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def readbuffer_encode(__data: str | bytes, __errors: str | None = ...) -> tuple[bytes, int]: ...
+def readbuffer_encode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.version_info >= (3, 9):
-    def unicode_escape_decode(__data: str | bytes, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
+    def unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = ..., __final: bool = ...
+    ) -> tuple[str, int]: ...
 
 else:
-    def unicode_escape_decode(__data: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+    def unicode_escape_decode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 
 def unicode_escape_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.version_info < (3, 8):
-    def unicode_internal_decode(__obj: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
-    def unicode_internal_encode(__obj: str | bytes, __errors: str | None = ...) -> tuple[bytes, int]: ...
+    def unicode_internal_decode(__obj: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
+    def unicode_internal_encode(__obj: str | ReadableBuffer, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
-def utf_16_be_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_16_be_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_16_be_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_16_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_16_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_16_encode(__str: str, __errors: str | None = ..., __byteorder: int = ...) -> tuple[bytes, int]: ...
 def utf_16_ex_decode(
-    __data: bytes, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
+    __data: ReadableBuffer, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
 ) -> tuple[str, int, int]: ...
-def utf_16_le_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_16_le_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_16_le_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_32_be_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_32_be_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_32_be_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_32_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_32_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_32_encode(__str: str, __errors: str | None = ..., __byteorder: int = ...) -> tuple[bytes, int]: ...
 def utf_32_ex_decode(
-    __data: bytes, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
+    __data: ReadableBuffer, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
 ) -> tuple[str, int, int]: ...
-def utf_32_le_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_32_le_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_32_le_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_7_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_7_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_7_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_8_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_8_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_8_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.platform == "win32":
-    def mbcs_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+    def mbcs_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
     def mbcs_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-    def code_page_decode(__codepage: int, __data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+    def code_page_decode(
+        __codepage: int, __data: ReadableBuffer, __errors: str | None = ..., __final: int = ...
+    ) -> tuple[str, int]: ...
     def code_page_encode(__code_page: int, __str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-    def oem_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+    def oem_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
     def oem_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...

mypy/typeshed/stdlib/_curses.pyi

@@ -1,9 +1,10 @@
 import sys
-from _typeshed import SupportsRead
+from _typeshed import ReadOnlyBuffer, SupportsRead
 from typing import IO, Any, NamedTuple, overload
 from typing_extensions import TypeAlias, final
 
 if sys.platform != "win32":
+    # Handled by PyCurses_ConvertToChtype in _cursesmodule.c.
     _ChType: TypeAlias = str | bytes | int
 
     # ACS codes are only initialized after initscr is called
@@ -330,7 +331,7 @@ if sys.platform != "win32":
     def noraw() -> None: ...
     def pair_content(__pair_number: int) -> tuple[int, int]: ...
     def pair_number(__attr: int) -> int: ...
-    def putp(__string: bytes) -> None: ...
+    def putp(__string: ReadOnlyBuffer) -> None: ...
     def qiflush(__flag: bool = ...) -> None: ...
     def raw(__flag: bool = ...) -> None: ...
     def reset_prog_mode() -> None: ...
@@ -352,7 +353,7 @@ if sys.platform != "win32":
     def tigetnum(__capname: str) -> int: ...
     def tigetstr(__capname: str) -> bytes | None: ...
     def tparm(
-        __str: bytes,
+        __str: ReadOnlyBuffer,
         __i1: int = ...,
         __i2: int = ...,
         __i3: int = ...,

mypy/typeshed/stdlib/_msi.pyi

@@ -12,11 +12,11 @@ if sys.platform == "win32":
         # Don't exist at runtime
         __new__: None  # type: ignore[assignment]
         __init__: None  # type: ignore[assignment]
-    # Actual typename Summary, not exposed by the implementation
-    class _Summary:
-        def GetProperty(self, propid: int) -> str | bytes | None: ...
+    # Actual typename SummaryInformation, not exposed by the implementation
+    class _SummaryInformation:
+        def GetProperty(self, field: int) -> int | bytes | None: ...
         def GetPropertyCount(self) -> int: ...
-        def SetProperty(self, propid: int, value: str | bytes) -> None: ...
+        def SetProperty(self, field: int, value: int | str) -> None: ...
         def Persist(self) -> None: ...
         # Don't exist at runtime
         __new__: None  # type: ignore[assignment]
@@ -25,7 +25,7 @@ if sys.platform == "win32":
     class _Database:
         def OpenView(self, sql: str) -> _View: ...
         def Commit(self) -> None: ...
-        def GetSummaryInformation(self, updateCount: int) -> _Summary: ...
+        def GetSummaryInformation(self, updateCount: int) -> _SummaryInformation: ...
         def Close(self) -> None: ...
         # Don't exist at runtime
         __new__: None  # type: ignore[assignment]

mypy/typeshed/stdlib/_posixsubprocess.pyi

@@ -1,24 +1,32 @@
 import sys
+from _typeshed import StrOrBytesPath
 from collections.abc import Callable, Sequence
+from typing_extensions import SupportsIndex
 
 if sys.platform != "win32":
     def cloexec_pipe() -> tuple[int, int]: ...
     def fork_exec(
-        args: Sequence[str],
-        executable_list: Sequence[bytes],
-        close_fds: bool,
-        fds_to_keep: Sequence[int],
-        cwd: str,
-        env_list: Sequence[bytes],
-        p2cread: int,
-        p2cwrite: int,
-        c2pred: int,
-        c2pwrite: int,
-        errread: int,
-        errwrite: int,
-        errpipe_read: int,
-        errpipe_write: int,
-        restore_signals: int,
-        start_new_session: int,
-        preexec_fn: Callable[[], None],
+        __process_args: Sequence[StrOrBytesPath] | None,
+        __executable_list: Sequence[bytes],
+        __close_fds: bool,
+        __fds_to_keep: tuple[int, ...],
+        __cwd_obj: str,
+        __env_list: Sequence[bytes] | None,
+        __p2cread: int,
+        __p2cwrite: int,
+        __c2pred: int,
+        __c2pwrite: int,
+        __errread: int,
+        __errwrite: int,
+        __errpipe_read: int,
+        __errpipe_write: int,
+        __restore_signals: int,
+        __call_setsid: int,
+        __pgid_to_set: int,
+        __gid_object: SupportsIndex | None,
+        __groups_list: list[int] | None,
+        __uid_object: SupportsIndex | None,
+        __child_umask: int,
+        __preexec_fn: Callable[[], None],
+        __allow_vfork: bool,
     ) -> int: ...

mypy/typeshed/stdlib/_socket.pyi

@@ -15,10 +15,10 @@ _CMSG: TypeAlias = tuple[int, int, bytes]
 _CMSGArg: TypeAlias = tuple[int, int, ReadableBuffer]
 
 # Addresses can be either tuples of varying lengths (AF_INET, AF_INET6,
-# AF_NETLINK, AF_TIPC) or strings (AF_UNIX).
-_Address: TypeAlias = tuple[Any, ...] | str
+# AF_NETLINK, AF_TIPC) or strings/buffers (AF_UNIX).
+# See getsockaddrarg() in socketmodule.c.
+_Address: TypeAlias = tuple[Any, ...] | str | ReadableBuffer
 _RetAddress: TypeAlias = Any
-# TODO Most methods allow bytes as address objects
 
 # ----- Constants -----
 # Some socket families are listed in the "Socket families" section of the docs,
@@ -584,10 +584,10 @@ class socket:
     @property
     def timeout(self) -> float | None: ...
     def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: _FD | None = ...) -> None: ...
-    def bind(self, __address: _Address | bytes) -> None: ...
+    def bind(self, __address: _Address) -> None: ...
     def close(self) -> None: ...
-    def connect(self, __address: _Address | bytes) -> None: ...
-    def connect_ex(self, __address: _Address | bytes) -> int: ...
+    def connect(self, __address: _Address) -> None: ...
+    def connect_ex(self, __address: _Address) -> int: ...
     def detach(self) -> int: ...
     def fileno(self) -> int: ...
     def getpeername(self) -> _RetAddress: ...
@@ -634,7 +634,7 @@ class socket:
     def setblocking(self, __flag: bool) -> None: ...
     def settimeout(self, __value: float | None) -> None: ...
     @overload
-    def setsockopt(self, __level: int, __optname: int, __value: int | bytes) -> None: ...
+    def setsockopt(self, __level: int, __optname: int, __value: int | ReadableBuffer) -> None: ...
     @overload
     def setsockopt(self, __level: int, __optname: int, __value: None, __optlen: int) -> None: ...
     if sys.platform == "win32":
@@ -671,9 +671,9 @@ def ntohs(__x: int) -> int: ...  # param & ret val are 16-bit ints
 def htonl(__x: int) -> int: ...  # param & ret val are 32-bit ints
 def htons(__x: int) -> int: ...  # param & ret val are 16-bit ints
 def inet_aton(__ip_string: str) -> bytes: ...  # ret val 4 bytes in length
-def inet_ntoa(__packed_ip: bytes) -> str: ...
+def inet_ntoa(__packed_ip: ReadableBuffer) -> str: ...
 def inet_pton(__address_family: int, __ip_string: str) -> bytes: ...
-def inet_ntop(__address_family: int, __packed_ip: bytes) -> str: ...
+def inet_ntop(__address_family: int, __packed_ip: ReadableBuffer) -> str: ...
 def getdefaulttimeout() -> float | None: ...
 def setdefaulttimeout(__timeout: float | None) -> None: ...
 

mypy/typeshed/stdlib/_tkinter.pyi

@@ -17,8 +17,10 @@ from typing_extensions import Literal, final
 #    (<textindex object: '1.0'>, <textindex object: '2.0'>)
 @final
 class Tcl_Obj:
-    string: str | bytes
-    typename: str
+    @property
+    def string(self) -> str: ...
+    @property
+    def typename(self) -> str: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, __other): ...
     def __ge__(self, __other): ...

mypy/typeshed/stdlib/_typeshed/__init__.pyi

@@ -234,6 +234,7 @@ else:
     WriteableBuffer: TypeAlias = bytearray | memoryview | array.array[Any] | mmap.mmap | ctypes._CData  # stable
 # Same as _WriteableBuffer, but also includes read-only buffer types (like bytes).
 ReadableBuffer: TypeAlias = ReadOnlyBuffer | WriteableBuffer  # stable
+_BufferWithLen: TypeAlias = ReadableBuffer  # not stable  # noqa: Y047
 
 ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
 OptExcInfo: TypeAlias = Union[ExcInfo, tuple[None, None, None]]

mypy/typeshed/stdlib/_winapi.pyi

@@ -1,4 +1,5 @@
 import sys
+from _typeshed import ReadableBuffer
 from collections.abc import Sequence
 from typing import Any, NoReturn, overload
 from typing_extensions import Literal, final
@@ -198,11 +199,11 @@ if sys.platform == "win32":
     def WaitForSingleObject(__handle: int, __milliseconds: int) -> int: ...
     def WaitNamedPipe(__name: str, __timeout: int) -> None: ...
     @overload
-    def WriteFile(handle: int, buffer: bytes, overlapped: Literal[True]) -> tuple[Overlapped, int]: ...
+    def WriteFile(handle: int, buffer: ReadableBuffer, overlapped: Literal[True]) -> tuple[Overlapped, int]: ...
     @overload
-    def WriteFile(handle: int, buffer: bytes, overlapped: Literal[False] = ...) -> tuple[int, int]: ...
+    def WriteFile(handle: int, buffer: ReadableBuffer, overlapped: Literal[False] = ...) -> tuple[int, int]: ...
     @overload
-    def WriteFile(handle: int, buffer: bytes, overlapped: int | bool) -> tuple[Any, int]: ...
+    def WriteFile(handle: int, buffer: ReadableBuffer, overlapped: int | bool) -> tuple[Any, int]: ...
     @final
     class Overlapped:
         event: int

mypy/typeshed/stdlib/abc.pyi

@@ -16,10 +16,7 @@ class ABCMeta(type):
             __mcls: type[Self], __name: str, __bases: tuple[type, ...], __namespace: dict[str, Any], **kwargs: Any
         ) -> Self: ...
     else:
-        # pyright doesn't like the first parameter being called mcls, hence the `pyright: ignore`
-        def __new__(
-            mcls: type[Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any  # pyright: ignore
-        ) -> Self: ...
+        def __new__(mcls: type[Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any) -> Self: ...
 
     def __instancecheck__(cls: ABCMeta, instance: Any) -> Any: ...
     def __subclasscheck__(cls: ABCMeta, subclass: Any) -> Any: ...

mypy/typeshed/stdlib/antigravity.pyi

@@ -1 +1,3 @@
-def geohash(latitude: float, longitude: float, datedow: bytes) -> None: ...
+from _typeshed import ReadableBuffer
+
+def geohash(latitude: float, longitude: float, datedow: ReadableBuffer) -> None: ...

mypy/typeshed/stdlib/array.pyi

@@ -21,15 +21,19 @@ class array(MutableSequence[_T], Generic[_T]):
     @property
     def itemsize(self) -> int: ...
     @overload
-    def __init__(self: array[int], __typecode: _IntTypeCode, __initializer: bytes | Iterable[int] = ...) -> None: ...
+    def __init__(self: array[int], __typecode: _IntTypeCode, __initializer: bytes | bytearray | Iterable[int] = ...) -> None: ...
     @overload
-    def __init__(self: array[float], __typecode: _FloatTypeCode, __initializer: bytes | Iterable[float] = ...) -> None: ...
+    def __init__(
+        self: array[float], __typecode: _FloatTypeCode, __initializer: bytes | bytearray | Iterable[float] = ...
+    ) -> None: ...
     @overload
-    def __init__(self: array[str], __typecode: _UnicodeTypeCode, __initializer: bytes | Iterable[str] = ...) -> None: ...
+    def __init__(
+        self: array[str], __typecode: _UnicodeTypeCode, __initializer: bytes | bytearray | Iterable[str] = ...
+    ) -> None: ...
     @overload
     def __init__(self, __typecode: str, __initializer: Iterable[_T]) -> None: ...
     @overload
-    def __init__(self, __typecode: str, __initializer: bytes = ...) -> None: ...
+    def __init__(self, __typecode: str, __initializer: bytes | bytearray = ...) -> None: ...
     def append(self, __v: _T) -> None: ...
     def buffer_info(self) -> tuple[int, int]: ...
     def byteswap(self) -> None: ...
@@ -52,7 +56,7 @@ class array(MutableSequence[_T], Generic[_T]):
     def tolist(self) -> list[_T]: ...
     def tounicode(self) -> str: ...
     if sys.version_info < (3, 9):
-        def fromstring(self, __buffer: bytes) -> None: ...
+        def fromstring(self, __buffer: str | ReadableBuffer) -> None: ...
         def tostring(self) -> bytes: ...
 
     def __len__(self) -> int: ...