[ty] Sync vendored typeshed stubs (#23642)

Close and reopen this PR to trigger CI

---------

Co-authored-by: typeshedbot <>

Author: github-actions[bot]

crates/ty_vendored/vendor/typeshed/README.md

@@ -38,7 +38,7 @@ you can install the type stubs using
 $ pip install types-html5lib types-requests
 ```
 
-These PyPI packages follow [PEP 561](http://www.python.org/dev/peps/pep-0561/)
+These PyPI packages follow [the typing spec standards](https://typing.python.org/en/latest/spec/distributing.html)
 and are automatically released (up to once a day) by
 [typeshed internal machinery](https://github.com/typeshed-internal/stub_uploader).
 

crates/ty_vendored/vendor/typeshed/source_commit.txt

@@ -1 +1 @@
-1b3cec156330a93f6bb22b6636bca38c27f8f721
+843c1fd5a148da85e523c1b4ee680226f89986aa

crates/ty_vendored/vendor/typeshed/stdlib/_thread.pyi

@@ -9,7 +9,7 @@ from collections.abc import Callable
 from threading import Thread
 from types import TracebackType
 from typing import Any, Final, NoReturn, final, overload
-from typing_extensions import TypeVarTuple, Unpack, disjoint_base
+from typing_extensions import TypeVarTuple, Unpack, deprecated, disjoint_base
 
 _Ts = TypeVarTuple("_Ts")
 
@@ -119,13 +119,16 @@ if sys.version_info >= (3, 13):
         def locked(self) -> bool:
             """Return whether the lock is in the locked state."""
 
-        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool:
+        @deprecated("Obsolete synonym. Use `acquire()` instead.")
+        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool:  # undocumented
             """An obsolete synonym of acquire()."""
 
-        def release_lock(self) -> None:
+        @deprecated("Obsolete synonym. Use `release()` instead.")
+        def release_lock(self) -> None:  # undocumented
             """An obsolete synonym of release()."""
 
-        def locked_lock(self) -> bool:
+        @deprecated("Obsolete synonym. Use `locked()` instead.")
+        def locked_lock(self) -> bool:  # undocumented
             """An obsolete synonym of locked()."""
 
         def __enter__(self) -> bool:
@@ -180,7 +183,8 @@ else:
             Return whether the lock is in the locked state.
             """
 
-        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool:
+        @deprecated("Obsolete synonym. Use `acquire()` instead.")
+        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool:  # undocumented
             """acquire(blocking=True, timeout=-1) -> bool
             (acquire_lock() is an obsolete synonym)
 
@@ -192,7 +196,8 @@ else:
             The blocking operation is interruptible.
             """
 
-        def release_lock(self) -> None:
+        @deprecated("Obsolete synonym. Use `release()` instead.")
+        def release_lock(self) -> None:  # undocumented
             """release()
             (release_lock() is an obsolete synonym)
 
@@ -201,7 +206,8 @@ else:
             but it needn't be locked by the same thread that unlocks it.
             """
 
-        def locked_lock(self) -> bool:
+        @deprecated("Obsolete synonym. Use `locked()` instead.")
+        def locked_lock(self) -> bool:  # undocumented
             """locked() -> bool
             (locked_lock() is an obsolete synonym)
 
@@ -245,14 +251,14 @@ def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpa
 
 @overload
 def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
-
-# Obsolete synonym for start_new_thread()
 @overload
-def start_new(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int:
+@deprecated("Obsolete synonym. Use `start_new_thread()` instead.")
+def start_new(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int:  # undocumented
     """An obsolete synonym of start_new_thread()."""
 
 @overload
-def start_new(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
+@deprecated("Obsolete synonym. Use `start_new_thread()` instead.")
+def start_new(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...  # undocumented
 
 if sys.version_info >= (3, 10):
     def interrupt_main(signum: signal.Signals = signal.SIGINT, /) -> None:
@@ -277,15 +283,17 @@ def exit() -> NoReturn:
     thread to exit silently unless the exception is caught.
     """
 
-def exit_thread() -> NoReturn:  # Obsolete synonym for exit()
+@deprecated("Obsolete synonym. Use `exit()` instead.")
+def exit_thread() -> NoReturn:  # undocumented
     """An obsolete synonym of exit()."""
 
 def allocate_lock() -> LockType:
     """Create a new lock object. See help(type(threading.Lock())) for
     information about locks.
     """
 
-def allocate() -> LockType:  # Obsolete synonym for allocate_lock()
+@deprecated("Obsolete synonym. Use `allocate_lock()` instead.")
+def allocate() -> LockType:  # undocumented
     """An obsolete synonym of allocate_lock()."""
 
 def get_ident() -> int:

crates/ty_vendored/vendor/typeshed/stdlib/abc.pyi

@@ -37,10 +37,10 @@ class ABCMeta(type):
             mcls: type[_typeshed.Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any
         ) -> _typeshed.Self: ...
 
-    def __instancecheck__(cls: ABCMeta, instance: Any) -> bool:
+    def __instancecheck__(cls: ABCMeta, instance: Any, /) -> bool:
         """Override for isinstance(instance, cls)."""
 
-    def __subclasscheck__(cls: ABCMeta, subclass: type) -> bool:
+    def __subclasscheck__(cls: ABCMeta, subclass: type, /) -> bool:
         """Override for issubclass(subclass, cls)."""
 
     def _dump_registry(cls: ABCMeta, file: SupportsWrite[str] | None = None) -> None:

crates/ty_vendored/vendor/typeshed/stdlib/asyncio/tasks.pyi

@@ -609,7 +609,6 @@ else:
         """
 
 if sys.version_info >= (3, 11):
-    @overload
     async def wait(
         fs: Iterable[_FT], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
     ) -> tuple[set[_FT], set[_FT]]:
@@ -627,11 +626,6 @@ if sys.version_info >= (3, 11):
         when the timeout occurs are returned in the second set.
         """
 
-    @overload
-    async def wait(
-        fs: Iterable[Task[_T]], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
-    ) -> tuple[set[Task[_T]], set[Task[_T]]]: ...
-
 elif sys.version_info >= (3, 10):
     @overload
     async def wait(  # type: ignore[overload-overlap]

crates/ty_vendored/vendor/typeshed/stdlib/logging/__init__.pyi

@@ -1304,19 +1304,15 @@ def makeLogRecord(dict: Mapping[str, object]) -> LogRecord:
     instance.
     """
 
+@overload  # handlers is non-None
 def basicConfig(
     *,
-    filename: StrPath | None = ...,
-    filemode: str = ...,
-    format: str = ...,
-    datefmt: str | None = ...,
-    style: _FormatStyle = ...,
-    level: _Level | None = ...,
-    stream: SupportsWrite[str] | None = ...,
-    handlers: Iterable[Handler] | None = ...,
-    force: bool | None = ...,
-    encoding: str | None = ...,
-    errors: str | None = ...,
+    format: str = ...,  # default value depends on the value of `style`
+    datefmt: str | None = None,
+    style: _FormatStyle = "%",
+    level: _Level | None = None,
+    handlers: Iterable[Handler],
+    force: bool | None = False,
 ) -> None:
     """
     Do basic configuration for the logging system.
@@ -1386,6 +1382,31 @@ def basicConfig(
        Added the ``encoding`` and ``errors`` parameters.
     """
 
+@overload  # handlers is None, filename is passed (but possibly None)
+def basicConfig(
+    *,
+    filename: StrPath | None,
+    filemode: str = "a",
+    format: str = ...,  # default value depends on the value of `style`
+    datefmt: str | None = None,
+    style: _FormatStyle = "%",
+    level: _Level | None = None,
+    handlers: None = None,
+    force: bool | None = False,
+    encoding: str | None = None,
+    errors: str | None = "backslashreplace",
+) -> None: ...
+@overload  # handlers is None, filename is not passed
+def basicConfig(
+    *,
+    format: str = ...,  # default value depends on the value of `style`
+    datefmt: str | None = None,
+    style: _FormatStyle = "%",
+    level: _Level | None = None,
+    stream: SupportsWrite[str] | None = None,
+    handlers: None = None,
+    force: bool | None = False,
+) -> None: ...
 def shutdown(handlerList: Sequence[Any] = ...) -> None:  # handlerList is undocumented
     """
     Perform any cleanup actions in the logging system (e.g. flushing

crates/ty_vendored/vendor/typeshed/stdlib/multiprocessing/managers.pyi

@@ -26,6 +26,8 @@ from .util import Finalize as _Finalize
 __all__ = ["BaseManager", "SyncManager", "BaseProxy", "Token", "SharedMemoryManager"]
 
 _T = TypeVar("_T")
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
 _KT = TypeVar("_KT")
 _VT = TypeVar("_VT")
 _S = TypeVar("_S")
@@ -114,6 +116,25 @@ if sys.version_info >= (3, 13):
         def keys(self) -> list[_KT]: ...  # type: ignore[override]
         def items(self) -> list[tuple[_KT, _VT]]: ...  # type: ignore[override]
         def values(self) -> list[_VT]: ...  # type: ignore[override]
+        if sys.version_info >= (3, 14):
+            # Next methods are copied from builtins.dict
+            @overload
+            def fromkeys(self, iterable: Iterable[_T], value: None = None, /) -> dict[_T, Any | None]: ...
+            @overload
+            def fromkeys(self, iterable: Iterable[_T], value: _S, /) -> dict[_T, _S]: ...
+            def __reversed__(self) -> Iterator[_KT]: ...
+            @overload
+            def __or__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
+            @overload
+            def __or__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
+            @overload
+            def __ror__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
+            @overload
+            def __ror__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
+            @overload  # type: ignore[misc]
+            def __ior__(self, value: SupportsKeysAndGetItem[_KT, _VT], /) -> Self: ...
+            @overload
+            def __ior__(self, value: Iterable[tuple[_KT, _VT]], /) -> Self: ...
 
     class DictProxy(_BaseDictProxy[_KT, _VT]):
         def __class_getitem__(cls, args: Any, /) -> GenericAlias:
@@ -217,6 +238,8 @@ class BaseListProxy(BaseProxy, MutableSequence[_T]):
     def insert(self, index: SupportsIndex, object: _T, /) -> None: ...
     def remove(self, value: _T, /) -> None: ...
     if sys.version_info >= (3, 14):
+        # Next methods are copied from builtins.list
+        def clear(self) -> None: ...
         def copy(self) -> list[_T]: ...
     # Use BaseListProxy[SupportsRichComparisonT] for the first overload rather than [SupportsRichComparison]
     # to work around invariance

crates/ty_vendored/vendor/typeshed/stdlib/multiprocessing/queues.pyi

@@ -1,15 +1,21 @@
 import sys
 from types import GenericAlias
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, NewType, TypeVar
 
 __all__ = ["Queue", "SimpleQueue", "JoinableQueue"]
 
 _T = TypeVar("_T")
 
+_QueueState = NewType("_QueueState", object)
+_JoinableQueueState = NewType("_JoinableQueueState", object)
+_SimpleQueueState = NewType("_SimpleQueueState", object)
+
 class Queue(Generic[_T]):
     # FIXME: `ctx` is a circular dependency and it's not actually optional.
     # It's marked as such to be able to use the generic Queue in __init__.pyi.
     def __init__(self, maxsize: int = 0, *, ctx: Any = ...) -> None: ...
+    def __getstate__(self) -> _QueueState: ...
+    def __setstate__(self, state: _QueueState) -> None: ...
     def put(self, obj: _T, block: bool = True, timeout: float | None = None) -> None: ...
     def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
     def qsize(self) -> int: ...
@@ -28,13 +34,17 @@ class Queue(Generic[_T]):
             """
 
 class JoinableQueue(Queue[_T]):
+    def __getstate__(self) -> _JoinableQueueState: ...  # type: ignore[override]
+    def __setstate__(self, state: _JoinableQueueState) -> None: ...  # type: ignore[override]
     def task_done(self) -> None: ...
     def join(self) -> None: ...
 
 class SimpleQueue(Generic[_T]):
     def __init__(self, *, ctx: Any = ...) -> None: ...
     def close(self) -> None: ...
     def empty(self) -> bool: ...
+    def __getstate__(self) -> _SimpleQueueState: ...
+    def __setstate__(self, state: _SimpleQueueState) -> None: ...
     def get(self) -> _T: ...
     def put(self, obj: _T) -> None: ...
     def __class_getitem__(cls, item: Any, /) -> GenericAlias:

crates/ty_vendored/vendor/typeshed/stdlib/opcode.pyi

@@ -46,8 +46,8 @@ if sys.version_info >= (3, 13):
 opname: Final[list[str]]
 
 opmap: Final[dict[str, int]]
-HAVE_ARGUMENT: Final = 43
-EXTENDED_ARG: Final = 69
+HAVE_ARGUMENT: Final[int]
+EXTENDED_ARG: Final[int]
 
 def stack_effect(opcode: int, oparg: int | None = None, /, *, jump: bool | None = None) -> int:
     """Compute the stack effect of the opcode."""

crates/ty_vendored/vendor/typeshed/stdlib/pickle.pyi

@@ -23,6 +23,7 @@ Misc variables:
 
 """
 
+import sys
 from _pickle import (
     PickleError as PickleError,
     Pickler as Pickler,
@@ -128,7 +129,10 @@ __all__ = [
 ]
 
 HIGHEST_PROTOCOL: Final = 5
-DEFAULT_PROTOCOL: Final = 5
+if sys.version_info >= (3, 14):
+    DEFAULT_PROTOCOL: Final = 5
+else:
+    DEFAULT_PROTOCOL: Final = 4
 
 bytes_types: tuple[type[Any], ...]  # undocumented