Sync typeshed (#17833)

Source commit:

python/typeshed@a94c927

mypy/typeshed/stdlib/VERSIONS

@@ -161,6 +161,8 @@ importlib.metadata._meta: 3.10-
 importlib.metadata.diagnose: 3.13-
 importlib.readers: 3.10-
 importlib.resources: 3.7-
+importlib.resources._common: 3.11-
+importlib.resources._functional: 3.13-
 importlib.resources.abc: 3.11-
 importlib.resources.readers: 3.11-
 importlib.resources.simple: 3.11-

mypy/typeshed/stdlib/importlib/abc.pyi

@@ -145,10 +145,10 @@ if sys.version_info >= (3, 9):
         # which is not the case.
         @overload
         @abstractmethod
-        def open(self, mode: Literal["r"] = "r", /, *, encoding: str | None = None, errors: str | None = None) -> IO[str]: ...
+        def open(self, mode: Literal["r"] = "r", *, encoding: str | None = None, errors: str | None = None) -> IO[str]: ...
         @overload
         @abstractmethod
-        def open(self, mode: Literal["rb"], /) -> IO[bytes]: ...
+        def open(self, mode: Literal["rb"]) -> IO[bytes]: ...
         @property
         @abstractmethod
         def name(self) -> str: ...

mypy/typeshed/stdlib/importlib/resources/__init__.pyi

@@ -7,37 +7,61 @@ from types import ModuleType
 from typing import Any, BinaryIO, TextIO
 from typing_extensions import TypeAlias
 
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import Package as Package
+else:
+    Package: TypeAlias = str | ModuleType
+
 if sys.version_info >= (3, 9):
     from importlib.abc import Traversable
 
-__all__ = ["Package", "Resource", "contents", "is_resource", "open_binary", "open_text", "path", "read_binary", "read_text"]
+__all__ = ["Package", "contents", "is_resource", "open_binary", "open_text", "path", "read_binary", "read_text"]
 
 if sys.version_info >= (3, 9):
     __all__ += ["as_file", "files"]
 
 if sys.version_info >= (3, 10):
     __all__ += ["ResourceReader"]
 
-Package: TypeAlias = str | ModuleType
+if sys.version_info < (3, 13):
+    __all__ += ["Resource"]
 
-if sys.version_info >= (3, 11):
-    Resource: TypeAlias = str
-else:
+if sys.version_info < (3, 11):
     Resource: TypeAlias = str | os.PathLike[Any]
+elif sys.version_info < (3, 13):
+    Resource: TypeAlias = str
 
-def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
-def open_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> TextIO: ...
-def read_binary(package: Package, resource: Resource) -> bytes: ...
-def read_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> str: ...
-def path(package: Package, resource: Resource) -> AbstractContextManager[Path]: ...
-def is_resource(package: Package, name: str) -> bool: ...
-def contents(package: Package) -> Iterator[str]: ...
+if sys.version_info >= (3, 13):
+    from importlib.resources._common import Anchor as Anchor
 
-if sys.version_info >= (3, 9):
+    __all__ += ["Anchor"]
+
+    from importlib.resources._functional import (
+        contents as contents,
+        is_resource as is_resource,
+        open_binary as open_binary,
+        open_text as open_text,
+        path as path,
+        read_binary as read_binary,
+        read_text as read_text,
+    )
+
+else:
+    def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
+    def open_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> TextIO: ...
+    def read_binary(package: Package, resource: Resource) -> bytes: ...
+    def read_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> str: ...
+    def path(package: Package, resource: Resource) -> AbstractContextManager[Path]: ...
+    def is_resource(package: Package, name: str) -> bool: ...
+    def contents(package: Package) -> Iterator[str]: ...
+
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import as_file as as_file
+elif sys.version_info >= (3, 9):
     def as_file(path: Traversable) -> AbstractContextManager[Path]: ...
 
-if sys.version_info >= (3, 12):
-    def files(anchor: Package | None = ...) -> Traversable: ...
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import files as files
 
 elif sys.version_info >= (3, 9):
     def files(package: Package) -> Traversable: ...

mypy/typeshed/stdlib/importlib/resources/_common.pyi

@@ -0,0 +1,42 @@
+import sys
+
+# Even though this file is 3.11+ only, Pyright will complain in stubtest for older versions.
+if sys.version_info >= (3, 11):
+    import types
+    from collections.abc import Callable
+    from contextlib import AbstractContextManager
+    from importlib.abc import ResourceReader, Traversable
+    from pathlib import Path
+    from typing import overload
+    from typing_extensions import TypeAlias, deprecated
+
+    Package: TypeAlias = str | types.ModuleType
+
+    if sys.version_info >= (3, 12):
+        Anchor: TypeAlias = Package
+
+        def package_to_anchor(
+            func: Callable[[Anchor | None], Traversable]
+        ) -> Callable[[Anchor | None, Anchor | None], Traversable]: ...
+        @overload
+        def files(anchor: Anchor | None = None) -> Traversable: ...
+        @overload
+        @deprecated("First parameter to files is renamed to 'anchor'")
+        def files(package: Anchor | None = None) -> Traversable: ...
+
+    else:
+        def files(package: Package) -> Traversable: ...
+
+    def get_resource_reader(package: types.ModuleType) -> ResourceReader | None: ...
+
+    if sys.version_info >= (3, 12):
+        def resolve(cand: Anchor | None) -> types.ModuleType: ...
+
+    else:
+        def resolve(cand: Package) -> types.ModuleType: ...
+
+    if sys.version_info < (3, 12):
+        def get_package(package: Package) -> types.ModuleType: ...
+
+    def from_package(package: types.ModuleType) -> Traversable: ...
+    def as_file(path: Traversable) -> AbstractContextManager[Path]: ...

mypy/typeshed/stdlib/importlib/resources/_functional.pyi

@@ -0,0 +1,30 @@
+import sys
+
+# Even though this file is 3.13+ only, Pyright will complain in stubtest for older versions.
+if sys.version_info >= (3, 13):
+    from _typeshed import StrPath
+    from collections.abc import Iterator
+    from contextlib import AbstractContextManager
+    from importlib.resources._common import Anchor
+    from io import TextIOWrapper
+    from pathlib import Path
+    from typing import BinaryIO, overload
+    from typing_extensions import Unpack
+
+    def open_binary(anchor: Anchor, *path_names: StrPath) -> BinaryIO: ...
+    @overload
+    def open_text(
+        anchor: Anchor, *path_names: Unpack[tuple[StrPath]], encoding: str | None = "utf-8", errors: str | None = "strict"
+    ) -> TextIOWrapper: ...
+    @overload
+    def open_text(anchor: Anchor, *path_names: StrPath, encoding: str | None, errors: str | None = "strict") -> TextIOWrapper: ...
+    def read_binary(anchor: Anchor, *path_names: StrPath) -> bytes: ...
+    @overload
+    def read_text(
+        anchor: Anchor, *path_names: Unpack[tuple[StrPath]], encoding: str | None = "utf-8", errors: str | None = "strict"
+    ) -> str: ...
+    @overload
+    def read_text(anchor: Anchor, *path_names: StrPath, encoding: str | None, errors: str | None = "strict") -> str: ...
+    def path(anchor: Anchor, *path_names: StrPath) -> AbstractContextManager[Path]: ...
+    def is_resource(anchor: Anchor, *path_names: StrPath) -> bool: ...
+    def contents(anchor: Anchor, *path_names: StrPath) -> Iterator[str]: ...

mypy/typeshed/stdlib/nt.pyi

@@ -107,5 +107,7 @@ if sys.platform == "win32":
             listvolumes as listvolumes,
             set_blocking as set_blocking,
         )
+    if sys.version_info >= (3, 13):
+        from os import fchmod as fchmod, lchmod as lchmod
 
     environ: dict[str, str]

mypy/typeshed/stdlib/os/__init__.pyi

@@ -673,7 +673,6 @@ if sys.version_info >= (3, 12) or sys.platform != "win32":
     def set_blocking(fd: int, blocking: bool, /) -> None: ...
 
 if sys.platform != "win32":
-    def fchmod(fd: int, mode: int) -> None: ...
     def fchown(fd: int, uid: int, gid: int) -> None: ...
     def fpathconf(fd: int, name: str | int, /) -> int: ...
     def fstatvfs(fd: int, /) -> statvfs_result: ...
@@ -754,7 +753,6 @@ def chmod(path: FileDescriptorOrPath, mode: int, *, dir_fd: int | None = None, f
 if sys.platform != "win32" and sys.platform != "linux":
     def chflags(path: StrOrBytesPath, flags: int, follow_symlinks: bool = True) -> None: ...  # some flavors of Unix
     def lchflags(path: StrOrBytesPath, flags: int) -> None: ...
-    def lchmod(path: StrOrBytesPath, mode: int) -> None: ...
 
 if sys.platform != "win32":
     def chroot(path: StrOrBytesPath) -> None: ...
@@ -1179,3 +1177,12 @@ if sys.version_info >= (3, 13) and sys.platform == "linux":
     def timerfd_settime_ns(fd: FileDescriptor, /, *, flags: int = 0, initial: int = 0, interval: int = 0) -> tuple[int, int]: ...
     def timerfd_gettime(fd: FileDescriptor, /) -> tuple[float, float]: ...
     def timerfd_gettime_ns(fd: FileDescriptor, /) -> tuple[int, int]: ...
+
+if sys.version_info >= (3, 13) or sys.platform != "win32":
+    # Added to Windows in 3.13.
+    def fchmod(fd: int, mode: int) -> None: ...
+
+if sys.platform != "linux":
+    if sys.version_info >= (3, 13) or sys.platform != "win32":
+        # Added to Windows in 3.13.
+        def lchmod(path: StrOrBytesPath, mode: int) -> None: ...

mypy/typeshed/stdlib/tkinter/__init__.pyi

@@ -3025,27 +3025,133 @@ class Text(Widget, XView, YView):
     config = configure
     def bbox(self, index: _TextIndex) -> tuple[int, int, int, int] | None: ...  # type: ignore[override]
     def compare(self, index1: _TextIndex, op: Literal["<", "<=", "==", ">=", ">", "!="], index2: _TextIndex) -> bool: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex) -> tuple[int] | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /) -> tuple[int] | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: Literal["update"], arg2: _WhatToCount, /) -> int | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: Literal["update"], /) -> int | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /) -> tuple[int, int]: ...
-    @overload
-    def count(
-        self,
-        index1: _TextIndex,
-        index2: _TextIndex,
-        arg1: _WhatToCount | Literal["update"],
-        arg2: _WhatToCount | Literal["update"],
-        arg3: _WhatToCount | Literal["update"],
-        /,
-        *args: _WhatToCount | Literal["update"],
-    ) -> tuple[int, ...]: ...
+    if sys.version_info >= (3, 13):
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, *, return_ints: Literal[True]) -> int: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /, *, return_ints: Literal[True]
+        ) -> int: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: Literal["update"],
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[True],
+        ) -> int: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: Literal["update"],
+            /,
+            *,
+            return_ints: Literal[True],
+        ) -> int: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /, *, return_ints: Literal[True]
+        ) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+            return_ints: Literal[True],
+        ) -> tuple[int, ...]: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, *, return_ints: Literal[False] = False) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg: _WhatToCount | Literal["update"],
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: Literal["update"],
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> int | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: Literal["update"],
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> int | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+            return_ints: Literal[False] = False,
+        ) -> tuple[int, ...]: ...
+    else:
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /
+        ) -> tuple[int] | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: Literal["update"], arg2: _WhatToCount, /) -> int | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: Literal["update"], /) -> int | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+        ) -> tuple[int, ...]: ...
+
     @overload
     def debug(self, boolean: None = None) -> bool: ...
     @overload

mypy/typeshed/stdlib/typing.pyi

@@ -540,7 +540,7 @@ class AsyncIterator(AsyncIterable[_T_co], Protocol[_T_co]):
     def __aiter__(self) -> AsyncIterator[_T_co]: ...
 
 class AsyncGenerator(AsyncIterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra]):
-    def __anext__(self) -> Awaitable[_YieldT_co]: ...
+    def __anext__(self) -> Coroutine[Any, Any, _YieldT_co]: ...
     @abstractmethod
     def asend(self, value: _SendT_contra, /) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload