Sync typeshed (#13987)

Source commit:

python/typeshed@263427f

Co-authored-by: Shantanu <12621235+hauntsaninja@users.noreply.github.com>

mypy/typeshed/stdlib/_ast.pyi

@@ -329,7 +329,7 @@ class JoinedStr(expr):
 
 if sys.version_info < (3, 8):
     class Num(expr):  # Deprecated in 3.8; use Constant
-        n: complex
+        n: int | float | complex
 
     class Str(expr):  # Deprecated in 3.8; use Constant
         s: str
@@ -349,7 +349,7 @@ class Constant(expr):
     kind: str | None
     # Aliases for value, for backwards compatibility
     s: Any
-    n: complex
+    n: int | float | complex
 
 if sys.version_info >= (3, 8):
     class NamedExpr(expr):

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/_decimal.pyi

@@ -4,7 +4,7 @@ from _typeshed import Self
 from collections.abc import Container, Sequence
 from types import TracebackType
 from typing import Any, ClassVar, NamedTuple, Union, overload
-from typing_extensions import TypeAlias
+from typing_extensions import Literal, TypeAlias
 
 _Decimal: TypeAlias = Decimal | int
 _DecimalNew: TypeAlias = Union[Decimal, float, str, tuple[int, Sequence[int], int]]
@@ -16,7 +16,7 @@ __libmpdec_version__: str
 class DecimalTuple(NamedTuple):
     sign: int
     digits: tuple[int, ...]
-    exponent: int
+    exponent: int | Literal["n", "N", "F"]
 
 ROUND_DOWN: str
 ROUND_HALF_UP: str

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/_operator.pyi

@@ -1,5 +1,6 @@
 import sys
-from collections.abc import Callable, Container, Iterable, Mapping, MutableMapping, MutableSequence, Sequence
+from _typeshed import SupportsGetItem
+from collections.abc import Callable, Container, Iterable, MutableMapping, MutableSequence, Sequence
 from typing import Any, AnyStr, Generic, Protocol, SupportsAbs, TypeVar, overload
 from typing_extensions import ParamSpec, SupportsIndex, TypeAlias, final
 
@@ -77,11 +78,9 @@ def delitem(__a: MutableSequence[Any], __b: slice) -> None: ...
 @overload
 def delitem(__a: MutableMapping[_K, Any], __b: _K) -> None: ...
 @overload
-def getitem(__a: Sequence[_T], __b: SupportsIndex) -> _T: ...
-@overload
 def getitem(__a: Sequence[_T], __b: slice) -> Sequence[_T]: ...
 @overload
-def getitem(__a: Mapping[_K, _V], __b: _K) -> _V: ...
+def getitem(__a: SupportsGetItem[_K, _V], __b: _K) -> _V: ...
 def indexOf(__a: Iterable[_T], __b: _T) -> int: ...
 @overload
 def setitem(__a: MutableSequence[_T], __b: SupportsIndex, __c: _T) -> None: ...
@@ -106,17 +105,30 @@ class attrgetter(Generic[_T_co]):
 
 @final
 class itemgetter(Generic[_T_co]):
+    # mypy lacks support for PEP 646 https://github.com/python/mypy/issues/12280
+    # So we have to define all of these overloads to simulate unpacking the arguments
     @overload
-    def __new__(cls, item: Any) -> itemgetter[Any]: ...
+    def __new__(cls, item: _T_co) -> itemgetter[_T_co]: ...
     @overload
-    def __new__(cls, item: Any, __item2: Any) -> itemgetter[tuple[Any, Any]]: ...
+    def __new__(cls, item: _T_co, __item2: _T_co) -> itemgetter[tuple[_T_co, _T_co]]: ...
     @overload
-    def __new__(cls, item: Any, __item2: Any, __item3: Any) -> itemgetter[tuple[Any, Any, Any]]: ...
+    def __new__(cls, item: _T_co, __item2: _T_co, __item3: _T_co) -> itemgetter[tuple[_T_co, _T_co, _T_co]]: ...
     @overload
-    def __new__(cls, item: Any, __item2: Any, __item3: Any, __item4: Any) -> itemgetter[tuple[Any, Any, Any, Any]]: ...
+    def __new__(
+        cls, item: _T_co, __item2: _T_co, __item3: _T_co, __item4: _T_co
+    ) -> itemgetter[tuple[_T_co, _T_co, _T_co, _T_co]]: ...
     @overload
-    def __new__(cls, item: Any, *items: Any) -> itemgetter[tuple[Any, ...]]: ...
-    def __call__(self, obj: Any) -> _T_co: ...
+    def __new__(
+        cls, item: _T_co, __item2: _T_co, __item3: _T_co, __item4: _T_co, *items: _T_co
+    ) -> itemgetter[tuple[_T_co, ...]]: ...
+    # __key: _KT_contra in SupportsGetItem seems to be causing variance issues, ie:
+    # TypeVar "_KT_contra@SupportsGetItem" is contravariant
+    #   "tuple[int, int]" is incompatible with protocol "SupportsIndex"
+    # preventing [_T_co, ...] instead of [Any, ...]
+    #
+    # A suspected mypy issue prevents using [..., _T] instead of [..., Any] here.
+    # https://github.com/python/mypy/issues/14032
+    def __call__(self, obj: SupportsGetItem[Any, Any]) -> Any: ...
 
 @final
 class methodcaller:

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,
@@ -583,11 +583,15 @@ class socket:
     def proto(self) -> int: ...
     @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: ...
+    if sys.platform == "win32":
+        def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: _FD | bytes | None = ...) -> None: ...
+    else:
+        def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: _FD | None = ...) -> 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 +638,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 +675,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): ...