[ty] Sync vendored typeshed stubs (#20658)

---------

Co-authored-by: typeshedbot <>
Co-authored-by: David Peter <[email protected]>

Author: github-actions[bot]

crates/ty_ide/src/goto_type_definition.rs

@@ -561,13 +561,13 @@ f(**kwargs<CURSOR>)
 
         assert_snapshot!(test.goto_type_definition(), @r#"
         info[goto-type-definition]: Type definition
-           --> stdlib/types.pyi:941:11
+           --> stdlib/types.pyi:950:11
             |
-        939 | if sys.version_info >= (3, 10):
-        940 |     @final
-        941 |     class NoneType:
+        948 | if sys.version_info >= (3, 10):
+        949 |     @final
+        950 |     class NoneType:
             |           ^^^^^^^^
-        942 |         """The type of the None singleton."""
+        951 |         """The type of the None singleton."""
             |
         info: Source
          --> main.py:3:5

crates/ty_python_semantic/resources/mdtest/call/replace.md

@@ -17,7 +17,8 @@ from datetime import time
 t = time(12, 0, 0)
 t = replace(t, minute=30)
 
-reveal_type(t)  # revealed: time
+# TODO: this should be `time`, once we support specialization of generic protocols
+reveal_type(t)  # revealed: Unknown
 ```
 
 ## The `__replace__` protocol
@@ -47,7 +48,8 @@ b = a.__replace__(x=3, y=4)
 reveal_type(b)  # revealed: Point
 
 b = replace(a, x=3, y=4)
-reveal_type(b)  # revealed: Point
+# TODO: this should be `Point`, once we support specialization of generic protocols
+reveal_type(b)  # revealed: Unknown
 ```
 
 A call to `replace` does not require all keyword arguments:
@@ -57,7 +59,8 @@ c = a.__replace__(y=4)
 reveal_type(c)  # revealed: Point
 
 d = replace(a, y=4)
-reveal_type(d)  # revealed: Point
+# TODO: this should be `Point`, once we support specialization of generic protocols
+reveal_type(d)  # revealed: Unknown
 ```
 
 Invalid calls to `__replace__` or `replace` will raise an error:

crates/ty_python_semantic/src/types/class.rs

@@ -4403,8 +4403,8 @@ impl KnownClass {
         KnownClassDisplay { db, class: self }
     }
 
-    /// Lookup a [`KnownClass`] in typeshed and return a [`Type`]
-    /// representing all possible instances of the class.
+    /// Lookup a [`KnownClass`] in typeshed and return a [`Type`] representing all possible instances of
+    /// the class. If this class is generic, this will use the default specialization.
     ///
     /// If the class cannot be found in typeshed, a debug-level log message will be emitted stating this.
     pub(crate) fn to_instance(self, db: &dyn Db) -> Type<'_> {
@@ -4414,6 +4414,14 @@ impl KnownClass {
             .unwrap_or_else(Type::unknown)
     }
 
+    /// Similar to [`KnownClass::to_instance`], but returns the Unknown-specialization where each type
+    /// parameter is specialized to `Unknown`.
+    pub(crate) fn to_instance_unknown(self, db: &dyn Db) -> Type<'_> {
+        self.try_to_class_literal(db)
+            .map(|literal| Type::instance(db, literal.unknown_specialization(db)))
+            .unwrap_or_else(Type::unknown)
+    }
+
     /// Lookup a generic [`KnownClass`] in typeshed and return a [`Type`]
     /// representing a specialization of that class.
     ///

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -1923,16 +1923,18 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 //
                 // If type arguments are supplied to `(Async)Iterable`, `(Async)Iterator`,
                 // `(Async)Generator` or `(Async)GeneratorType` in the return annotation,
-                // we should iterate over the `yield` expressions and `return` statements in the function
-                // to check that they are consistent with the type arguments provided.
+                // we should iterate over the `yield` expressions and `return` statements
+                // in the function to check that they are consistent with the type arguments
+                // provided. Once we do this, the `.to_instance_unknown` call below should
+                // be replaced with `.to_specialized_instance`.
                 let inferred_return = if function.is_async {
                     KnownClass::AsyncGeneratorType
                 } else {
                     KnownClass::GeneratorType
                 };
 
                 if !inferred_return
-                    .to_instance(self.db())
+                    .to_instance_unknown(self.db())
                     .is_assignable_to(self.db(), expected_ty)
                 {
                     report_invalid_generator_function_return_type(

crates/ty_vendored/vendor/typeshed/source_commit.txt

@@ -1 +1 @@
-47dbbd6c914a5190d54bc5bd498d1e6633d97db2
+91055c730ffcda6311654cf32d663858ece69bad

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

@@ -6,12 +6,13 @@ Unit tests are in test_collections.
 import sys
 from abc import abstractmethod
 from types import MappingProxyType
-from typing import (  # noqa: Y022,Y038,UP035
+from typing import (  # noqa: Y022,Y038,UP035,Y057
     AbstractSet as Set,
     AsyncGenerator as AsyncGenerator,
     AsyncIterable as AsyncIterable,
     AsyncIterator as AsyncIterator,
     Awaitable as Awaitable,
+    ByteString as ByteString,
     Callable as Callable,
     ClassVar,
     Collection as Collection,
@@ -64,12 +65,8 @@ __all__ = [
     "ValuesView",
     "Sequence",
     "MutableSequence",
+    "ByteString",
 ]
-if sys.version_info < (3, 14):
-    from typing import ByteString as ByteString  # noqa: Y057,UP035
-
-    __all__ += ["ByteString"]
-
 if sys.version_info >= (3, 12):
     __all__ += ["Buffer"]
 

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

@@ -22,7 +22,7 @@ def __import__(
     name: str,
     globals: Mapping[str, object] | None = None,
     locals: Mapping[str, object] | None = None,
-    fromlist: Sequence[str] = (),
+    fromlist: Sequence[str] | None = (),
     level: int = 0,
 ) -> ModuleType:
     """Import a module.

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

@@ -57,34 +57,34 @@ _TkinterTraceFunc: TypeAlias = Callable[[tuple[str, ...]], object]
 @final
 class TkappType:
     # Please keep in sync with tkinter.Tk
-    def adderrorinfo(self, msg, /): ...
+    def adderrorinfo(self, msg: str, /): ...
     def call(self, command: Any, /, *args: Any) -> Any: ...
-    def createcommand(self, name, func, /): ...
+    def createcommand(self, name: str, func, /): ...
     if sys.platform != "win32":
-        def createfilehandler(self, file, mask, func, /): ...
-        def deletefilehandler(self, file, /): ...
+        def createfilehandler(self, file, mask: int, func, /): ...
+        def deletefilehandler(self, file, /) -> None: ...
 
-    def createtimerhandler(self, milliseconds, func, /): ...
-    def deletecommand(self, name, /): ...
+    def createtimerhandler(self, milliseconds: int, func, /): ...
+    def deletecommand(self, name: str, /): ...
     def dooneevent(self, flags: int = 0, /): ...
     def eval(self, script: str, /) -> str: ...
-    def evalfile(self, fileName, /): ...
-    def exprboolean(self, s, /): ...
-    def exprdouble(self, s, /): ...
-    def exprlong(self, s, /): ...
-    def exprstring(self, s, /): ...
-    def getboolean(self, arg, /): ...
-    def getdouble(self, arg, /): ...
-    def getint(self, arg, /): ...
+    def evalfile(self, fileName: str, /): ...
+    def exprboolean(self, s: str, /): ...
+    def exprdouble(self, s: str, /): ...
+    def exprlong(self, s: str, /): ...
+    def exprstring(self, s: str, /): ...
+    def getboolean(self, arg, /) -> bool: ...
+    def getdouble(self, arg, /) -> float: ...
+    def getint(self, arg, /) -> int: ...
     def getvar(self, *args, **kwargs): ...
     def globalgetvar(self, *args, **kwargs): ...
     def globalsetvar(self, *args, **kwargs): ...
     def globalunsetvar(self, *args, **kwargs): ...
     def interpaddr(self) -> int: ...
     def loadtk(self) -> None: ...
-    def mainloop(self, threshold: int = 0, /): ...
-    def quit(self): ...
-    def record(self, script, /): ...
+    def mainloop(self, threshold: int = 0, /) -> None: ...
+    def quit(self) -> None: ...
+    def record(self, script: str, /): ...
     def setvar(self, *ags, **kwargs): ...
     if sys.version_info < (3, 11):
         @deprecated("Deprecated since Python 3.9; removed in Python 3.11. Use `splitlist()` instead.")
@@ -93,7 +93,7 @@ class TkappType:
     def splitlist(self, arg, /): ...
     def unsetvar(self, *args, **kwargs): ...
     def wantobjects(self, *args, **kwargs): ...
-    def willdispatch(self): ...
+    def willdispatch(self) -> None: ...
     if sys.version_info >= (3, 12):
         def gettrace(self, /) -> _TkinterTraceFunc | None:
             """Get the tracing function."""
@@ -164,10 +164,10 @@ else:
           if not None, then pass -use to wish
         """
 
-def getbusywaitinterval():
+def getbusywaitinterval() -> int:
     """Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter."""
 
-def setbusywaitinterval(new_val, /):
+def setbusywaitinterval(new_val: int, /) -> None:
     """Set the busy-wait interval in milliseconds between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.
 
     It should be set to a divisor of the maximum time between frames in an animation.

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

@@ -1,5 +1,6 @@
 """Tools to analyze tasks running in asyncio programs."""
 
+import sys
 from collections.abc import Iterable
 from enum import Enum
 from typing import NamedTuple, SupportsIndex, type_check_only
@@ -48,6 +49,15 @@ def build_async_tree(result: Iterable[_AwaitedInfo], task_emoji: str = "(T)", co
     """
 
 def build_task_table(result: Iterable[_AwaitedInfo]) -> list[list[int | str]]: ...
+
+if sys.version_info >= (3, 14):
+    def exit_with_permission_help_text() -> None:
+        """
+        Prints a message pointing to platform-specific permission help text and exits the program.
+        This function is called when a PermissionError is encountered while trying
+        to attach to a process.
+        """
+
 def display_awaited_by_tasks_table(pid: SupportsIndex) -> None:
     """Build and print a table of all pending tasks under `pid`."""
 

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

@@ -4153,7 +4153,14 @@ def open(
     opener: _Opener | None = None,
 ) -> IO[Any]: ...
 def ord(c: str | bytes | bytearray, /) -> int:
-    """Return the Unicode code point for a one-character string."""
+    """Return the ordinal value of a character.
+
+    If the argument is a one-character string, return the Unicode code
+    point of that character.
+
+    If the argument is a bytes or bytearray object of length 1, return its
+    single byte value.
+    """
 
 @type_check_only
 class _SupportsWriteAndFlush(SupportsWrite[_T_contra], SupportsFlush, Protocol[_T_contra]): ...
@@ -4451,7 +4458,7 @@ def __import__(
     name: str,
     globals: Mapping[str, object] | None = None,
     locals: Mapping[str, object] | None = None,
-    fromlist: Sequence[str] = (),
+    fromlist: Sequence[str] | None = (),
     level: int = 0,
 ) -> types.ModuleType:
     """Import a module.