Updated typeshed stubs to the latest version.

Author: erictraut

packages/pyright-internal/typeshed-fallback/README.md

@@ -46,6 +46,59 @@ and are automatically released (multiple times a day, when needed) by
 Type checkers should be able to use these stub packages when installed. For more
 details, see the documentation for your type checker.
 
+### Package versioning for third-party stubs
+
+Version numbers of third-party stub packages consist of at least four parts.
+All parts of the stub version, except for the last part, correspond to the
+version of the runtime package being stubbed. For example, if the `types-foo`
+package has version `1.2.0.7`, this guarantees that the `types-foo` package
+contains stubs targeted against `foo==1.2.*` and tested against the latest
+version of `foo` matching that specifier. In this example, the final element
+of the version (7) indicates that this is the eighth revision of the stubs for
+`foo==1.2.*`. If an update to the stubs were pushed (but the stubs were still
+aiming to provide annotations for `foo==1.2.*`), then the version of
+`types-foo` would increment to `1.2.0.8`.
+
+At typeshed, we try to keep breaking changes to a minimum. However, due to the
+nature of stubs, any version bump can introduce changes that might make your
+code fail to type check.
+
+There are several strategies available for specifying the version of a stubs
+package you're using, each with its own tradeoffs:
+
+1. Use the same bounds that you use for the package being stubbed. For example,
+   if you use `requests>=2.30.0,<2.32`, you can use
+   `types-requests>=2.30.0,<2.32`. This ensures that the stubs are compatible
+   with the package you are using, but it carries a small risk of breaking
+   type checking due to changes in the stubs.
+
+   Another risk of this strategy is that stubs often lag behind
+   the package being stubbed. You might want to force the package being stubbed
+   to a certain minimum version because it fixes a critical bug, but if
+   correspondingly updated stubs have not been released, your type
+   checking results may not be fully accurate.
+2. Pin the stubs to a known good version and update the pin from time to time
+   (either manually, or using a tool such as dependabot or renovate).
+
+   For example, if you use `types-requests==2.31.0.1`, you can have confidence
+   that upgrading dependencies will not break type checking. However, you will
+   miss out on improvements in the stubs that could potentially improve type
+   checking until you update the pin. This strategy also has the risk that the
+   stubs you are using might become incompatible with the package being stubbed.
+3. Don't pin the stubs. This is the option that demands the least work from
+   you when it comes to updating version pins, and has the advantage that you
+   will automatically benefit from improved stubs whenever a new version of the
+   stubs package is released. However, it carries the risk that the stubs
+   become incompatible with the package being stubbed.
+
+   For example, if a new major version of the package is released, there's a
+   chance the stubs might be updated to reflect the new version of the runtime
+   package before you update the package being stubbed.
+
+You can also switch between the different strategies as needed. For example,
+you could default to strategy (1), but fall back to strategy (2) when
+a problem arises that can't easily be fixed.
+
 ### The `_typeshed` package
 
 typeshed includes a package `_typeshed` as part of the standard library.

packages/pyright-internal/typeshed-fallback/commit.txt

@@ -1 +1 @@
-d27426488ed48fd54290db765702685ca596c0c5
+658dd55c41b5c458c8b45dd72837740a4004785b

packages/pyright-internal/typeshed-fallback/stdlib/VERSIONS

@@ -150,6 +150,7 @@ imaplib: 2.7-
 imghdr: 2.7-
 imp: 2.7-3.11
 importlib: 2.7-
+importlib._abc: 3.10-
 importlib.metadata: 3.8-
 importlib.metadata._meta: 3.10-
 importlib.readers: 3.10-

packages/pyright-internal/typeshed-fallback/stdlib/_ctypes.pyi

@@ -51,8 +51,8 @@ class _CDataMeta(type):
     # By default mypy complains about the following two methods, because strictly speaking cls
     # might not be a Type[_CT]. However this can never actually happen, because the only class that
     # uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here.
-    def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
-    def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]
+    def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]
 
 class _CData(metaclass=_CDataMeta):
     _b_base_: int

packages/pyright-internal/typeshed-fallback/stdlib/_operator.pyi

@@ -2,14 +2,17 @@ import sys
 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
+from typing_extensions import ParamSpec, SupportsIndex, TypeAlias, TypeVarTuple, Unpack, final
 
 _R = TypeVar("_R")
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
 _K = TypeVar("_K")
 _V = TypeVar("_V")
 _P = ParamSpec("_P")
+_Ts = TypeVarTuple("_Ts")
 
 # The following protocols return "Any" instead of bool, since the comparison
 # operators can be overloaded to return an arbitrary object. For example,
@@ -105,22 +108,10 @@ 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: _T_co) -> itemgetter[_T_co]: ...
+    def __new__(cls, __item: _T) -> itemgetter[_T]: ...
     @overload
-    def __new__(cls, item: _T_co, __item2: _T_co) -> itemgetter[tuple[_T_co, _T_co]]: ...
-    @overload
-    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: _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: _T_co, __item2: _T_co, __item3: _T_co, __item4: _T_co, *items: _T_co
-    ) -> itemgetter[tuple[_T_co, ...]]: ...
+    def __new__(cls, __item1: _T1, __item2: _T2, *items: Unpack[_Ts]) -> itemgetter[tuple[_T1, _T2, Unpack[_Ts]]]: ...
     # __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"

packages/pyright-internal/typeshed-fallback/stdlib/_typeshed/__init__.pyi

@@ -320,3 +320,12 @@ class DataclassInstance(Protocol):
 # Anything that can be passed to the int/float constructors
 ConvertibleToInt: TypeAlias = str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc
 ConvertibleToFloat: TypeAlias = str | ReadableBuffer | SupportsFloat | SupportsIndex
+
+# A few classes updated from Foo(str, Enum) to Foo(StrEnum). This is a convenience so these
+# can be accurate on all python versions without getting too wordy
+if sys.version_info >= (3, 11):
+    from enum import StrEnum as StrEnum
+else:
+    from enum import Enum
+
+    class StrEnum(str, Enum): ...

packages/pyright-internal/typeshed-fallback/stdlib/asyncio/base_events.pyi

@@ -11,14 +11,15 @@ from collections.abc import Callable, Iterable, Sequence
 from contextvars import Context
 from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
 from typing import IO, Any, TypeVar, overload
-from typing_extensions import Literal, TypeAlias
+from typing_extensions import Literal, TypeAlias, TypeVarTuple, Unpack
 
 if sys.version_info >= (3, 9):
     __all__ = ("BaseEventLoop", "Server")
 else:
     __all__ = ("BaseEventLoop",)
 
 _T = TypeVar("_T")
+_Ts = TypeVarTuple("_Ts")
 _ProtocolT = TypeVar("_ProtocolT", bound=BaseProtocol)
 _Context: TypeAlias = dict[str, Any]
 _ExceptionHandler: TypeAlias = Callable[[AbstractEventLoop, _Context], object]
@@ -71,12 +72,14 @@ class BaseEventLoop(AbstractEventLoop):
     def close(self) -> None: ...
     async def shutdown_asyncgens(self) -> None: ...
     # Methods scheduling callbacks.  All these return Handles.
-    def call_soon(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
+    def call_soon(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
     def call_later(
-        self, delay: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+        self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
     ) -> TimerHandle: ...
     def call_at(
-        self, when: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+        self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
     ) -> TimerHandle: ...
     def time(self) -> float: ...
     # Future methods
@@ -92,8 +95,10 @@ class BaseEventLoop(AbstractEventLoop):
     def set_task_factory(self, factory: _TaskFactory | None) -> None: ...
     def get_task_factory(self) -> _TaskFactory | None: ...
     # Methods for interacting with threads
-    def call_soon_threadsafe(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
-    def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Future[_T]: ...
+    def call_soon_threadsafe(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
+    def run_in_executor(self, executor: Any, func: Callable[[Unpack[_Ts]], _T], *args: Unpack[_Ts]) -> Future[_T]: ...
     def set_default_executor(self, executor: Any) -> None: ...
     # Network I/O methods returning Futures.
     async def getaddrinfo(
@@ -441,9 +446,9 @@ class BaseEventLoop(AbstractEventLoop):
         errors: None = None,
         **kwargs: Any,
     ) -> tuple[SubprocessTransport, _ProtocolT]: ...
-    def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     def remove_reader(self, fd: FileDescriptorLike) -> bool: ...
-    def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     def remove_writer(self, fd: FileDescriptorLike) -> bool: ...
     # The sock_* methods (and probably some others) are not actually implemented on
     # BaseEventLoop, only on subclasses. We list them here for now for convenience.
@@ -457,7 +462,7 @@ class BaseEventLoop(AbstractEventLoop):
         async def sock_recvfrom_into(self, sock: socket, buf: WriteableBuffer, nbytes: int = 0) -> tuple[int, _RetAddress]: ...
         async def sock_sendto(self, sock: socket, data: ReadableBuffer, address: _Address) -> int: ...
     # Signal handling.
-    def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_signal_handler(self, sig: int, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     def remove_signal_handler(self, sig: int) -> bool: ...
     # Error handlers.
     def set_exception_handler(self, handler: _ExceptionHandler | None) -> None: ...

packages/pyright-internal/typeshed-fallback/stdlib/asyncio/events.pyi

@@ -6,7 +6,7 @@ from collections.abc import Callable, Coroutine, Generator, Sequence
 from contextvars import Context
 from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
 from typing import IO, Any, Protocol, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias, deprecated
+from typing_extensions import Literal, Self, TypeAlias, TypeVarTuple, Unpack, deprecated
 
 from . import _AwaitableLike, _CoroutineLike
 from .base_events import Server
@@ -56,6 +56,7 @@ else:
     )
 
 _T = TypeVar("_T")
+_Ts = TypeVarTuple("_Ts")
 _ProtocolT = TypeVar("_ProtocolT", bound=BaseProtocol)
 _Context: TypeAlias = dict[str, Any]
 _ExceptionHandler: TypeAlias = Callable[[AbstractEventLoop, _Context], object]
@@ -131,22 +132,24 @@ class AbstractEventLoop:
     # Methods scheduling callbacks.  All these return Handles.
     if sys.version_info >= (3, 9):  # "context" added in 3.9.10/3.10.2
         @abstractmethod
-        def call_soon(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
+        def call_soon(
+            self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+        ) -> Handle: ...
         @abstractmethod
         def call_later(
-            self, delay: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+            self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
         ) -> TimerHandle: ...
         @abstractmethod
         def call_at(
-            self, when: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+            self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
         ) -> TimerHandle: ...
     else:
         @abstractmethod
-        def call_soon(self, callback: Callable[..., object], *args: Any) -> Handle: ...
+        def call_soon(self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> Handle: ...
         @abstractmethod
-        def call_later(self, delay: float, callback: Callable[..., object], *args: Any) -> TimerHandle: ...
+        def call_later(self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> TimerHandle: ...
         @abstractmethod
-        def call_at(self, when: float, callback: Callable[..., object], *args: Any) -> TimerHandle: ...
+        def call_at(self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> TimerHandle: ...
 
     @abstractmethod
     def time(self) -> float: ...
@@ -173,13 +176,15 @@ class AbstractEventLoop:
     # Methods for interacting with threads
     if sys.version_info >= (3, 9):  # "context" added in 3.9.10/3.10.2
         @abstractmethod
-        def call_soon_threadsafe(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
+        def call_soon_threadsafe(
+            self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+        ) -> Handle: ...
     else:
         @abstractmethod
-        def call_soon_threadsafe(self, callback: Callable[..., object], *args: Any) -> Handle: ...
+        def call_soon_threadsafe(self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> Handle: ...
 
     @abstractmethod
-    def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Future[_T]: ...
+    def run_in_executor(self, executor: Any, func: Callable[[Unpack[_Ts]], _T], *args: Unpack[_Ts]) -> Future[_T]: ...
     @abstractmethod
     def set_default_executor(self, executor: Any) -> None: ...
     # Network I/O methods returning Futures.
@@ -542,11 +547,11 @@ class AbstractEventLoop:
         **kwargs: Any,
     ) -> tuple[SubprocessTransport, _ProtocolT]: ...
     @abstractmethod
-    def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     @abstractmethod
     def remove_reader(self, fd: FileDescriptorLike) -> bool: ...
     @abstractmethod
-    def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     @abstractmethod
     def remove_writer(self, fd: FileDescriptorLike) -> bool: ...
     # Completion based I/O methods returning Futures prior to 3.7
@@ -569,7 +574,7 @@ class AbstractEventLoop:
         async def sock_sendto(self, sock: socket, data: ReadableBuffer, address: _Address) -> int: ...
     # Signal handling.
     @abstractmethod
-    def add_signal_handler(self, sig: int, callback: Callable[..., object], *args: Any) -> None: ...
+    def add_signal_handler(self, sig: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
     @abstractmethod
     def remove_signal_handler(self, sig: int) -> bool: ...
     # Error handlers.

packages/pyright-internal/typeshed-fallback/stdlib/asyncio/exceptions.pyi

@@ -21,7 +21,12 @@ else:
     )
 
 class CancelledError(BaseException): ...
-class TimeoutError(Exception): ...
+
+if sys.version_info >= (3, 11):
+    from builtins import TimeoutError as TimeoutError
+else:
+    class TimeoutError(Exception): ...
+
 class InvalidStateError(Exception): ...
 class SendfileNotAvailableError(RuntimeError): ...
 

packages/pyright-internal/typeshed-fallback/stdlib/asyncio/locks.pyi

@@ -10,8 +10,10 @@ from typing_extensions import Literal, Self
 from .events import AbstractEventLoop
 from .futures import Future
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 10):
     from .mixins import _LoopBoundMixin
+else:
+    _LoopBoundMixin = object
 
 if sys.version_info >= (3, 11):
     __all__ = ("Lock", "Event", "Condition", "Semaphore", "BoundedSemaphore", "Barrier")
@@ -44,7 +46,7 @@ else:
             self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
         ) -> None: ...
 
-class Lock(_ContextManagerMixin):
+class Lock(_ContextManagerMixin, _LoopBoundMixin):
     if sys.version_info >= (3, 10):
         def __init__(self) -> None: ...
     else:
@@ -54,7 +56,7 @@ class Lock(_ContextManagerMixin):
     async def acquire(self) -> Literal[True]: ...
     def release(self) -> None: ...
 
-class Event:
+class Event(_LoopBoundMixin):
     if sys.version_info >= (3, 10):
         def __init__(self) -> None: ...
     else:
@@ -65,7 +67,7 @@ class Event:
     def clear(self) -> None: ...
     async def wait(self) -> Literal[True]: ...
 
-class Condition(_ContextManagerMixin):
+class Condition(_ContextManagerMixin, _LoopBoundMixin):
     if sys.version_info >= (3, 10):
         def __init__(self, lock: Lock | None = None) -> None: ...
     else:
@@ -79,7 +81,7 @@ class Condition(_ContextManagerMixin):
     def notify(self, n: int = 1) -> None: ...
     def notify_all(self) -> None: ...
 
-class Semaphore(_ContextManagerMixin):
+class Semaphore(_ContextManagerMixin, _LoopBoundMixin):
     _value: int
     _waiters: deque[Future[Any]]
     if sys.version_info >= (3, 10):