Sync Linux docstrings

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

@@ -1,11 +1,68 @@
+"""Record of phased-in incompatible language changes.
+
+Each line is of the form:
+
+    FeatureName = "_Feature(" OptionalRelease "," MandatoryRelease ","
+                              CompilerFlag ")"
+
+where, normally, OptionalRelease < MandatoryRelease, and both are 5-tuples
+of the same form as sys.version_info:
+
+    (PY_MAJOR_VERSION, # the 2 in 2.1.0a3; an int
+     PY_MINOR_VERSION, # the 1; an int
+     PY_MICRO_VERSION, # the 0; an int
+     PY_RELEASE_LEVEL, # "alpha", "beta", "candidate" or "final"; string
+     PY_RELEASE_SERIAL # the 3; an int
+    )
+
+OptionalRelease records the first release in which
+
+    from __future__ import FeatureName
+
+was accepted.
+
+In the case of MandatoryReleases that have not yet occurred,
+MandatoryRelease predicts the release in which the feature will become part
+of the language.
+
+Else MandatoryRelease records when the feature became part of the language;
+in releases at or after that, modules no longer need
+
+    from __future__ import FeatureName
+
+to use the feature in question, but may continue to use such imports.
+
+MandatoryRelease may also be None, meaning that a planned feature got
+dropped or that the release version is undetermined.
+
+Instances of class _Feature have two corresponding methods,
+.getOptionalRelease() and .getMandatoryRelease().
+
+CompilerFlag is the (bitfield) flag that should be passed in the fourth
+argument to the builtin function compile() to enable the feature in
+dynamically compiled code.  This flag is stored in the .compiler_flag
+attribute on _Future instances.  These values must match the appropriate
+#defines of CO_xxx flags in Include/cpython/compile.h.
+
+No feature line is ever to be deleted from this file.
+"""
 from typing_extensions import TypeAlias
 
 _VersionInfo: TypeAlias = tuple[int, int, int, str, int]
 
 class _Feature:
     def __init__(self, optionalRelease: _VersionInfo, mandatoryRelease: _VersionInfo | None, compiler_flag: int) -> None: ...
-    def getOptionalRelease(self) -> _VersionInfo: ...
+    def getOptionalRelease(self) -> _VersionInfo:
-    def getMandatoryRelease(self) -> _VersionInfo | None: ...
+        """Return first release in which this feature was recognized.
+
+This is a 5-tuple, of the same form as sys.version_info.
+"""
+    def getMandatoryRelease(self) -> _VersionInfo | None:
+        """Return release in which this feature will become mandatory.
+
+This is a 5-tuple, of the same form as sys.version_info, or, if
+the feature was dropped, or the release date is undetermined, is None.
+"""
     compiler_flag: int
 
 absolute_import: _Feature

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

@@ -1,3 +1,5 @@
+"""Accelerator module for asyncio
+"""
 import sys
 from asyncio.events import AbstractEventLoop
 from collections.abc import Awaitable, Callable, Coroutine, Generator
@@ -12,6 +14,19 @@ _TaskYieldType: TypeAlias = Future[object] | None
 
 @disjoint_base
 class Future(Awaitable[_T]):
+    """This class is *almost* compatible with concurrent.futures.Future.
+
+    Differences:
+
+    - result() and exception() do not take a timeout argument and
+      raise an exception when the future isn't done yet.
+
+    - Callbacks registered with add_done_callback() are always called
+      via the event loop's call_soon_threadsafe().
+
+    - This class is not compatible with the wait() and as_completed()
+      methods in the concurrent.futures package.
+"""
     _state: str
     @property
     def _exception(self) -> BaseException | None: ...
@@ -22,24 +37,80 @@ class Future(Awaitable[_T]):
     def _log_traceback(self, val: Literal[False]) -> None: ...
     _asyncio_future_blocking: bool  # is a part of duck-typing contract for `Future`
     def __init__(self, *, loop: AbstractEventLoop | None = None) -> None: ...
-    def __del__(self) -> None: ...
+    def __del__(self) -> None:
-    def get_loop(self) -> AbstractEventLoop: ...
+        """Called when the instance is about to be destroyed.
+"""
+    def get_loop(self) -> AbstractEventLoop:
+        """Return the event loop the Future is bound to.
+"""
     @property
     def _callbacks(self) -> list[tuple[Callable[[Self], Any], Context]]: ...
-    def add_done_callback(self, fn: Callable[[Self], object], /, *, context: Context | None = None) -> None: ...
+    def add_done_callback(self, fn: Callable[[Self], object], /, *, context: Context | None = None) -> None:
-    def cancel(self, msg: Any | None = None) -> bool: ...
+        """Add a callback to be run when the future becomes done.
-    def cancelled(self) -> bool: ...
+
-    def done(self) -> bool: ...
+The callback is called with a single argument - the future object. If
-    def result(self) -> _T: ...
+the future is already done when this is called, the callback is
-    def exception(self) -> BaseException | None: ...
+scheduled with call_soon.
-    def remove_done_callback(self, fn: Callable[[Self], object], /) -> int: ...
+"""
-    def set_result(self, result: _T, /) -> None: ...
+    def cancel(self, msg: Any | None = None) -> bool:
-    def set_exception(self, exception: type | BaseException, /) -> None: ...
+        """Cancel the future and schedule callbacks.
-    def __iter__(self) -> Generator[Any, None, _T]: ...
+
-    def __await__(self) -> Generator[Any, None, _T]: ...
+If the future is already done or cancelled, return False.  Otherwise,
+change the future's state to cancelled, schedule the callbacks and
+return True.
+"""
+    def cancelled(self) -> bool:
+        """Return True if the future was cancelled.
+"""
+    def done(self) -> bool:
+        """Return True if the future is done.
+
+Done means either that a result / exception are available, or that the
+future was cancelled.
+"""
+    def result(self) -> _T:
+        """Return the result this future represents.
+
+If the future has been cancelled, raises CancelledError.  If the
+future's result isn't yet available, raises InvalidStateError.  If
+the future is done and has an exception set, this exception is raised.
+"""
+    def exception(self) -> BaseException | None:
+        """Return the exception that was set on this future.
+
+The exception (or None if no exception was set) is returned only if
+the future is done.  If the future has been cancelled, raises
+CancelledError.  If the future isn't done yet, raises
+InvalidStateError.
+"""
+    def remove_done_callback(self, fn: Callable[[Self], object], /) -> int:
+        """Remove all instances of a callback from the "call when done" list.
+
+Returns the number of callbacks removed.
+"""
+    def set_result(self, result: _T, /) -> None:
+        """Mark the future done and set its result.
+
+If the future is already done when this method is called, raises
+InvalidStateError.
+"""
+    def set_exception(self, exception: type | BaseException, /) -> None:
+        """Mark the future done and set an exception.
+
+If the future is already done when this method is called, raises
+InvalidStateError.
+"""
+    def __iter__(self) -> Generator[Any, None, _T]:
+        """Implement iter(self).
+"""
+    def __await__(self) -> Generator[Any, None, _T]:
+        """Return an iterator to be used in await expression.
+"""
     @property
     def _loop(self) -> AbstractEventLoop: ...
-    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+        """See PEP 585
+"""
 
 if sys.version_info >= (3, 12):
     _TaskCompatibleCoro: TypeAlias = Coroutine[Any, Any, _T_co]
@@ -52,6 +123,8 @@ else:
 # and `asyncio.Task.set_result()` always raises.
 @disjoint_base
 class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportInvalidTypeArguments]
+    """A coroutine wrapped in a Future.
+"""
     if sys.version_info >= (3, 12):
         def __init__(
             self,
@@ -86,27 +159,118 @@ class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportIn
     if sys.version_info >= (3, 12):
         def get_context(self) -> Context: ...
 
-    def get_stack(self, *, limit: int | None = None) -> list[FrameType]: ...
+    def get_stack(self, *, limit: int | None = None) -> list[FrameType]:
-    def print_stack(self, *, limit: int | None = None, file: TextIO | None = None) -> None: ...
+        """Return the list of stack frames for this task's coroutine.
+
+If the coroutine is not done, this returns the stack where it is
+suspended.  If the coroutine has completed successfully or was
+cancelled, this returns an empty list.  If the coroutine was
+terminated by an exception, this returns the list of traceback
+frames.
+
+The frames are always ordered from oldest to newest.
+
+The optional limit gives the maximum number of frames to
+return; by default all available frames are returned.  Its
+meaning differs depending on whether a stack or a traceback is
+returned: the newest frames of a stack are returned, but the
+oldest frames of a traceback are returned.  (This matches the
+behavior of the traceback module.)
+
+For reasons beyond our control, only one stack frame is
+returned for a suspended coroutine.
+"""
+    def print_stack(self, *, limit: int | None = None, file: TextIO | None = None) -> None:
+        """Print the stack or traceback for this task's coroutine.
+
+This produces output similar to that of the traceback module,
+for the frames retrieved by get_stack().  The limit argument
+is passed to get_stack().  The file argument is an I/O stream
+to which the output is written; by default output is written
+to sys.stderr.
+"""
     if sys.version_info >= (3, 11):
-        def cancelling(self) -> int: ...
+        def cancelling(self) -> int:
-        def uncancel(self) -> int: ...
+            """Return the count of the task's cancellation requests.
 
-    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+This count is incremented when .cancel() is called
+and may be decremented using .uncancel().
+"""
+        def uncancel(self) -> int:
+            """Decrement the task's count of cancellation requests.
 
-def get_event_loop() -> AbstractEventLoop: ...
+This should be used by tasks that catch CancelledError
-def get_running_loop() -> AbstractEventLoop: ...
+and wish to continue indefinitely until they are cancelled again.
-def _set_running_loop(loop: AbstractEventLoop | None, /) -> None: ...
+
-def _get_running_loop() -> AbstractEventLoop: ...
+Returns the remaining number of cancellation requests.
-def _register_task(task: Task[Any]) -> None: ...
+"""
-def _unregister_task(task: Task[Any]) -> None: ...
+
-def _enter_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias:
-def _leave_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
+        """See PEP 585
+"""
+
+def get_event_loop() -> AbstractEventLoop:
+    """Return an asyncio event loop.
+
+When called from a coroutine or a callback (e.g. scheduled with
+call_soon or similar API), this function will always return the
+running event loop.
+
+If there is no running event loop set, the function will return
+the result of `get_event_loop_policy().get_event_loop()` call.
+"""
+def get_running_loop() -> AbstractEventLoop:
+    """Return the running event loop.  Raise a RuntimeError if there is none.
+
+This function is thread-specific.
+"""
+def _set_running_loop(loop: AbstractEventLoop | None, /) -> None:
+    """Set the running event loop.
+
+This is a low-level function intended to be used by event loops.
+This function is thread-specific.
+"""
+def _get_running_loop() -> AbstractEventLoop:
+    """Return the running event loop or None.
+
+This is a low-level function intended to be used by event loops.
+This function is thread-specific.
+"""
+def _register_task(task: Task[Any]) -> None:
+    """Register a new task in asyncio as executed by loop.
+
+Returns None.
+"""
+def _unregister_task(task: Task[Any]) -> None:
+    """Unregister a task.
+
+Returns None.
+"""
+def _enter_task(loop: AbstractEventLoop, task: Task[Any]) -> None:
+    """Enter into task execution or resume suspended task.
+
+Task belongs to loop.
+
+Returns None.
+"""
+def _leave_task(loop: AbstractEventLoop, task: Task[Any]) -> None:
+    """Leave task execution or suspend a task.
+
+Task belongs to loop.
+
+Returns None.
+"""
 
 if sys.version_info >= (3, 12):
-    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
+    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None:
+        """Return a currently executed task.
+"""
 
 if sys.version_info >= (3, 14):
     def future_discard_from_awaited_by(future: Future[Any], waiter: Future[Any], /) -> None: ...
-    def future_add_to_awaited_by(future: Future[Any], waiter: Future[Any], /) -> None: ...
+    def future_add_to_awaited_by(future: Future[Any], waiter: Future[Any], /) -> None:
-    def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
+        """Record that `fut` is awaited on by `waiter`.
+"""
+    def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]:
+        """Return a set of all tasks for the loop.
+"""

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

@@ -1,3 +1,10 @@
+"""Bisection algorithms.
+
+This module provides support for maintaining a list in sorted order without
+having to sort the list after each insertion. For long lists of items with
+expensive comparison operations, this can be an improvement over the more
+common approach.
+"""
 import sys
 from _typeshed import SupportsLenAndGetItem, SupportsRichComparisonT
 from collections.abc import Callable, MutableSequence
@@ -14,7 +21,18 @@ if sys.version_info >= (3, 10):
         hi: int | None = None,
         *,
         key: None = None,
-    ) -> int: ...
+    ) -> int:
+        """Return the index where to insert item x in list a, assuming a is sorted.
+
+The return value i is such that all e in a[:i] have e < x, and all e in
+a[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will
+insert just before the leftmost x already there.
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+
+A custom key function can be supplied to customize the sort order.
+"""
     @overload
     def bisect_left(
         a: SupportsLenAndGetItem[_T],
@@ -32,7 +50,18 @@ if sys.version_info >= (3, 10):
         hi: int | None = None,
         *,
         key: None = None,
-    ) -> int: ...
+    ) -> int:
+        """Return the index where to insert item x in list a, assuming a is sorted.
+
+The return value i is such that all e in a[:i] have e <= x, and all e in
+a[i:] have e > x.  So if x already appears in the list, a.insert(i, x) will
+insert just after the rightmost x already there.
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+
+A custom key function can be supplied to customize the sort order.
+"""
     @overload
     def bisect_right(
         a: SupportsLenAndGetItem[_T],
@@ -50,7 +79,16 @@ if sys.version_info >= (3, 10):
         hi: int | None = None,
         *,
         key: None = None,
-    ) -> None: ...
+    ) -> None:
+        """Insert item x in list a, and keep it sorted assuming a is sorted.
+
+If x is already in a, insert it to the left of the leftmost x.
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+
+A custom key function can be supplied to customize the sort order.
+"""
     @overload
     def insort_left(
         a: MutableSequence[_T], x: _T, lo: int = 0, hi: int | None = None, *, key: Callable[[_T], SupportsRichComparisonT]
@@ -63,7 +101,16 @@ if sys.version_info >= (3, 10):
         hi: int | None = None,
         *,
         key: None = None,
-    ) -> None: ...
+    ) -> None:
+        """Insert item x in list a, and keep it sorted assuming a is sorted.
+
+If x is already in a, insert it to the right of the rightmost x.
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+
+A custom key function can be supplied to customize the sort order.
+"""
     @overload
     def insort_right(
         a: MutableSequence[_T], x: _T, lo: int = 0, hi: int | None = None, *, key: Callable[[_T], SupportsRichComparisonT]
@@ -72,13 +119,45 @@ if sys.version_info >= (3, 10):
 else:
     def bisect_left(
         a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> int: ...
+    ) -> int:
+        """Return the index where to insert item x in list a, assuming a is sorted.
+
+The return value i is such that all e in a[:i] have e < x, and all e in
+a[i:] have e >= x.  So if x already appears in the list, i points just
+before the leftmost x already there.
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+"""
     def bisect_right(
         a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> int: ...
+    ) -> int:
+        """Return the index where to insert item x in list a, assuming a is sorted.
+
+The return value i is such that all e in a[:i] have e <= x, and all e in
+a[i:] have e > x.  So if x already appears in the list, i points just
+beyond the rightmost x already there
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+"""
     def insort_left(
         a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> None: ...
+    ) -> None:
+        """Insert item x in list a, and keep it sorted assuming a is sorted.
+
+If x is already in a, insert it to the left of the leftmost x.
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+"""
     def insort_right(
         a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> None: ...
+    ) -> None:
+        """Insert item x in list a, and keep it sorted assuming a is sorted.
+
+If x is already in a, insert it to the right of the rightmost x.
+
+Optional args lo (default 0) and hi (default len(a)) bound the
+slice of a to be searched.
+"""

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

@@ -1,3 +1,5 @@
+"""_blake2b provides BLAKE2b for hashlib
+"""
 import sys
 from _typeshed import ReadableBuffer
 from typing import ClassVar, Final, final
@@ -14,6 +16,8 @@ BLAKE2S_SALT_SIZE: Final = 8
 
 @final
 class blake2b:
+    """Return a new BLAKE2b hash object.
+"""
     MAX_DIGEST_SIZE: ClassVar[int] = 64
     MAX_KEY_SIZE: ClassVar[int] = 64
     PERSON_SIZE: ClassVar[int] = 16
@@ -60,13 +64,23 @@ class blake2b:
             usedforsecurity: bool = True,
         ) -> Self: ...
 
-    def copy(self) -> Self: ...
+    def copy(self) -> Self:
-    def digest(self) -> bytes: ...
+        """Return a copy of the hash object.
-    def hexdigest(self) -> str: ...
+"""
-    def update(self, data: ReadableBuffer, /) -> None: ...
+    def digest(self) -> bytes:
+        """Return the digest value as a bytes object.
+"""
+    def hexdigest(self) -> str:
+        """Return the digest value as a string of hexadecimal digits.
+"""
+    def update(self, data: ReadableBuffer, /) -> None:
+        """Update this hash object's state with the provided bytes-like object.
+"""
 
 @final
 class blake2s:
+    """Return a new BLAKE2s hash object.
+"""
     MAX_DIGEST_SIZE: ClassVar[int] = 32
     MAX_KEY_SIZE: ClassVar[int] = 32
     PERSON_SIZE: ClassVar[int] = 8
@@ -113,7 +127,15 @@ class blake2s:
             usedforsecurity: bool = True,
         ) -> Self: ...
 
-    def copy(self) -> Self: ...
+    def copy(self) -> Self:
-    def digest(self) -> bytes: ...
+        """Return a copy of the hash object.
-    def hexdigest(self) -> str: ...
+"""
-    def update(self, data: ReadableBuffer, /) -> None: ...
+    def digest(self) -> bytes:
+        """Return the digest value as a bytes object.
+"""
+    def hexdigest(self) -> str:
+        """Return the digest value as a string of hexadecimal digits.
+"""
+    def update(self, data: ReadableBuffer, /) -> None:
+        """Update this hash object's state with the provided bytes-like object.
+"""

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

@@ -1 +1,6 @@
+"""A minimal subset of the locale module used at interpreter startup
+(imported by the _io module), in order to reduce startup time.
+
+Don't import directly from third-party code; use the `locale` module instead!
+"""
 def getpreferredencoding(do_setlocale: bool = True) -> str: ...

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

@@ -5,20 +5,65 @@ from typing_extensions import Self
 
 @final
 class BZ2Compressor:
+    """Create a compressor object for compressing data incrementally.
+
+  compresslevel
+    Compression level, as a number between 1 and 9.
+
+For one-shot compression, use the compress() function instead.
+"""
     if sys.version_info >= (3, 12):
         def __new__(cls, compresslevel: int = 9, /) -> Self: ...
     else:
         def __init__(self, compresslevel: int = 9, /) -> None: ...
 
-    def compress(self, data: ReadableBuffer, /) -> bytes: ...
+    def compress(self, data: ReadableBuffer, /) -> bytes:
-    def flush(self) -> bytes: ...
+        """Provide data to the compressor object.
+
+Returns a chunk of compressed data if possible, or b'' otherwise.
+
+When you have finished providing data to the compressor, call the
+flush() method to finish the compression process.
+"""
+    def flush(self) -> bytes:
+        """Finish the compression process.
+
+Returns the compressed data left in internal buffers.
+
+The compressor object may not be used after this method is called.
+"""
 
 @final
 class BZ2Decompressor:
-    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    """Create a decompressor object for decompressing data incrementally.
+
+For one-shot decompression, use the decompress() function instead.
+"""
+    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes:
+        """Decompress *data*, returning uncompressed data as bytes.
+
+If *max_length* is nonnegative, returns at most *max_length* bytes of
+decompressed data. If this limit is reached and further output can be
+produced, *self.needs_input* will be set to ``False``. In this case, the next
+call to *decompress()* may provide *data* as b'' to obtain more of the output.
+
+If all of the input data was decompressed and returned (either because this
+was less than *max_length* bytes, or because *max_length* was negative),
+*self.needs_input* will be set to True.
+
+Attempting to decompress data after the end of stream is reached raises an
+EOFError.  Any data found after the end of the stream is ignored and saved in
+the unused_data attribute.
+"""
     @property
-    def eof(self) -> bool: ...
+    def eof(self) -> bool:
+        """True if the end-of-stream marker has been reached.
+"""
     @property
-    def needs_input(self) -> bool: ...
+    def needs_input(self) -> bool:
+        """True if more input is needed before more decompressed data can be produced.
+"""
     @property
-    def unused_data(self) -> bytes: ...
+    def unused_data(self) -> bytes:
+        """Data found after the end of the compressed stream.
+"""

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

@@ -16,13 +16,34 @@ _CharMap: TypeAlias = dict[int, int] | _EncodingMap
 _Handler: TypeAlias = Callable[[UnicodeError], tuple[str | bytes, int]]
 _SearchFunction: TypeAlias = Callable[[str], codecs.CodecInfo | None]
 
-def register(search_function: _SearchFunction, /) -> None: ...
+def register(search_function: _SearchFunction, /) -> None:
+    """Register a codec search function.
+
+Search functions are expected to take one argument, the encoding name in
+all lower case letters, and either return None, or a tuple of functions
+(encoder, decoder, stream_reader, stream_writer) (or a CodecInfo object).
+"""
 
 if sys.version_info >= (3, 10):
-    def unregister(search_function: _SearchFunction, /) -> None: ...
+    def unregister(search_function: _SearchFunction, /) -> None:
+        """Unregister a codec search function and clear the registry's cache.
 
-def register_error(errors: str, handler: _Handler, /) -> None: ...
+If the search function is not registered, do nothing.
-def lookup_error(name: str, /) -> _Handler: ...
+"""
+
+def register_error(errors: str, handler: _Handler, /) -> None:
+    """Register the specified error handler under the name errors.
+
+handler must be a callable object, that will be called with an exception
+instance containing information about the location of the encoding/decoding
+error and must return a (replacement, new position) tuple.
+"""
+def lookup_error(name: str, /) -> _Handler:
+    """lookup_error(errors) -> handler
+
+Return the error handler for the specified error handling name or raise a
+LookupError, if no handler exists under this name.
+"""
 
 # The type ignore on `encode` and `decode` is to avoid issues with overlapping overloads, for more details, see #300
 # https://docs.python.org/3/library/codecs.html#binary-transforms
@@ -48,13 +69,29 @@ _BytesToBytesEncoding: TypeAlias = Literal[
 _StrToStrEncoding: TypeAlias = Literal["rot13", "rot_13"]
 
 @overload
-def encode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes: ...
+def encode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes:
+    """Encodes obj using the codec registered for encoding.
+
+The default encoding is 'utf-8'.  errors may be given to set a
+different error handling scheme.  Default is 'strict' meaning that encoding
+errors raise a ValueError.  Other possible values are 'ignore', 'replace'
+and 'backslashreplace' as well as any other name registered with
+codecs.register_error that can handle ValueErrors.
+"""
 @overload
 def encode(obj: str, encoding: _StrToStrEncoding, errors: str = "strict") -> str: ...  # type: ignore[overload-overlap]
 @overload
 def encode(obj: str, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
 @overload
-def decode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes: ...  # type: ignore[overload-overlap]
+def decode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes:  # type: ignore[overload-overlap]
+    """Decodes obj using the codec registered for encoding.
+
+Default encoding is 'utf-8'.  errors may be given to set a
+different error handling scheme.  Default is 'strict' meaning that encoding
+errors raise a ValueError.  Other possible values are 'ignore', 'replace'
+and 'backslashreplace' as well as any other name registered with
+codecs.register_error that can handle ValueErrors.
+"""
 @overload
 def decode(obj: str, encoding: _StrToStrEncoding, errors: str = "strict") -> str: ...
 
@@ -71,7 +108,9 @@ def decode(
 def decode(obj: str, encoding: Literal["hex", "hex_codec"], errors: str = "strict") -> bytes: ...
 @overload
 def decode(obj: ReadableBuffer, encoding: str = "utf-8", errors: str = "strict") -> str: ...
-def lookup(encoding: str, /) -> codecs.CodecInfo: ...
+def lookup(encoding: str, /) -> codecs.CodecInfo:
+    """Looks up a codec tuple in the Python codec registry and returns a CodecInfo object.
+"""
 def charmap_build(map: str, /) -> _CharMap: ...
 def ascii_decode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
 def ascii_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...

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

@@ -1,3 +1,7 @@
+"""Abstract Base Classes (ABCs) for collections, according to PEP 3119.
+
+Unit tests are in test_collections.
+"""
 import sys
 from abc import abstractmethod
 from types import MappingProxyType
@@ -71,31 +75,47 @@ _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
 @final
 class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
-    def __reversed__(self) -> Iterator[_KT_co]: ...
+    def __reversed__(self) -> Iterator[_KT_co]:
+        """Return a reverse iterator over the dict keys.
+"""
     __hash__: ClassVar[None]  # type: ignore[assignment]
     if sys.version_info >= (3, 13):
-        def isdisjoint(self, other: Iterable[_KT_co], /) -> bool: ...
+        def isdisjoint(self, other: Iterable[_KT_co], /) -> bool:
+            """Return True if the view and the given iterable have a null intersection.
+"""
     if sys.version_info >= (3, 10):
         @property
-        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:
+            """dictionary that this view refers to
+"""
 
 @final
 class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
-    def __reversed__(self) -> Iterator[_VT_co]: ...
+    def __reversed__(self) -> Iterator[_VT_co]:
+        """Return a reverse iterator over the dict values.
+"""
     if sys.version_info >= (3, 10):
         @property
-        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:
+            """dictionary that this view refers to
+"""
 
 @final
 class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
-    def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...
+    def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]:
+        """Return a reverse iterator over the dict items.
+"""
     __hash__: ClassVar[None]  # type: ignore[assignment]
     if sys.version_info >= (3, 13):
-        def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool: ...
+        def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool:
+            """Return True if the view and the given iterable have a null intersection.
+"""
     if sys.version_info >= (3, 10):
         @property
-        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:
+            """dictionary that this view refers to
+"""
 
 if sys.version_info >= (3, 12):
     @runtime_checkable

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

@@ -1,3 +1,5 @@
+"""Internal classes used by the gzip, lzma and bz2 modules
+"""
 # _compression is replaced by compression._common._streams on Python 3.14+ (PEP-784)
 
 from _typeshed import ReadableBuffer, WriteableBuffer
@@ -24,9 +26,13 @@ class _Decompressor(Protocol):
     # @property
     # def needs_input(self) -> bool: ...
 
-class BaseStream(BufferedIOBase): ...
+class BaseStream(BufferedIOBase):
+    """Mode-checking helper functions.
+"""
 
 class DecompressReader(RawIOBase):
+    """Adapts the decompressor API to a RawIOBase reader API
+"""
     def __init__(
         self,
         fp: _Reader,

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

@@ -1,3 +1,5 @@
+"""Context Variables
+"""
 import sys
 from collections.abc import Callable, Iterator, Mapping
 from types import GenericAlias, TracebackType
@@ -18,14 +20,36 @@ class ContextVar(Generic[_T]):
     @property
     def name(self) -> str: ...
     @overload
-    def get(self) -> _T: ...
+    def get(self) -> _T:
+        """Return a value for the context variable for the current context.
+
+If there is no value for the variable in the current context, the method will:
+ * return the value of the default argument of the method, if provided; or
+ * return the default value for the context variable, if it was created
+   with one; or
+ * raise a LookupError.
+"""
     @overload
     def get(self, default: _T, /) -> _T: ...
     @overload
     def get(self, default: _D, /) -> _D | _T: ...
-    def set(self, value: _T, /) -> Token[_T]: ...
+    def set(self, value: _T, /) -> Token[_T]:
-    def reset(self, token: Token[_T], /) -> None: ...
+        """Call to set a new value for the context variable in the current context.
-    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+The required value argument is the new value for the context variable.
+
+Returns a Token object that can be used to restore the variable to its previous
+value via the `ContextVar.reset()` method.
+"""
+    def reset(self, token: Token[_T], /) -> None:
+        """Reset the context variable.
+
+The variable is reset to the value it had before the `ContextVar.set()` that
+created the token was used.
+"""
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+        """See PEP 585
+"""
 
 @final
 class Token(Generic[_T]):
@@ -35,12 +59,18 @@ class Token(Generic[_T]):
     def old_value(self) -> Any: ...  # returns either _T or MISSING, but that's hard to express
     MISSING: ClassVar[object]
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+        """See PEP 585
+"""
     if sys.version_info >= (3, 14):
-        def __enter__(self) -> Self: ...
+        def __enter__(self) -> Self:
+            """Enter into Token context manager.
+"""
         def __exit__(
             self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-        ) -> None: ...
+        ) -> None:
+            """Exit from Token context manager, restore the linked ContextVar.
+"""
 
 def copy_context() -> Context: ...
 
@@ -50,15 +80,28 @@ def copy_context() -> Context: ...
 class Context(Mapping[ContextVar[Any], Any]):
     def __init__(self) -> None: ...
     @overload
-    def get(self, key: ContextVar[_T], default: None = None, /) -> _T | None: ...
+    def get(self, key: ContextVar[_T], default: None = None, /) -> _T | None:
+        """Return the value for `key` if `key` has the value in the context object.
+
+If `key` does not exist, return `default`. If `default` is not given,
+return None.
+"""
     @overload
     def get(self, key: ContextVar[_T], default: _T, /) -> _T: ...
     @overload
     def get(self, key: ContextVar[_T], default: _D, /) -> _T | _D: ...
     def run(self, callable: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> _T: ...
-    def copy(self) -> Context: ...
+    def copy(self) -> Context:
+        """Return a shallow copy of the context object.
+"""
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __getitem__(self, key: ContextVar[_T], /) -> _T: ...
+    def __getitem__(self, key: ContextVar[_T], /) -> _T:
-    def __iter__(self) -> Iterator[ContextVar[Any]]: ...
+        """Return self[key].
-    def __len__(self) -> int: ...
+"""
+    def __iter__(self) -> Iterator[ContextVar[Any]]:
+        """Implement iter(self).
+"""
+    def __len__(self) -> int:
+        """Return len(self).
+"""
     def __eq__(self, value: object, /) -> bool: ...

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

@@ -1,3 +1,5 @@
+"""CSV parsing and writing.
+"""
 import csv
 import sys
 from _typeshed import SupportsWrite
@@ -26,6 +28,10 @@ _DialectLike: TypeAlias = str | Dialect | csv.Dialect | type[Dialect | csv.Diale
 
 @disjoint_base
 class Dialect:
+    """CSV dialect
+
+The Dialect type records CSV parsing and generation options.
+"""
     delimiter: str
     quotechar: str | None
     escapechar: str | None
@@ -51,23 +57,55 @@ if sys.version_info >= (3, 10):
     # This class calls itself _csv.reader.
     @disjoint_base
     class Reader:
+        """CSV reader
+
+Reader objects are responsible for reading and parsing tabular data
+in CSV format.
+"""
         @property
         def dialect(self) -> Dialect: ...
         line_num: int
-        def __iter__(self) -> Self: ...
+        def __iter__(self) -> Self:
-        def __next__(self) -> list[str]: ...
+            """Implement iter(self).
+"""
+        def __next__(self) -> list[str]:
+            """Implement next(self).
+"""
 
     # This class calls itself _csv.writer.
     @disjoint_base
     class Writer:
+        """CSV writer
+
+Writer objects are responsible for generating tabular data
+in CSV format from sequence input.
+"""
         @property
         def dialect(self) -> Dialect: ...
         if sys.version_info >= (3, 13):
-            def writerow(self, row: Iterable[Any], /) -> Any: ...
+            def writerow(self, row: Iterable[Any], /) -> Any:
-            def writerows(self, rows: Iterable[Iterable[Any]], /) -> None: ...
+                """Construct and write a CSV record from an iterable of fields.
+
+Non-string elements will be converted to string.
+"""
+            def writerows(self, rows: Iterable[Iterable[Any]], /) -> None:
+                """Construct and write a series of iterables to a csv file.
+
+Non-string elements will be converted to string.
+"""
         else:
-            def writerow(self, row: Iterable[Any]) -> Any: ...
+            def writerow(self, row: Iterable[Any]) -> Any:
-            def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
+                """writerow(iterable)
+
+Construct and write a CSV record from an iterable of fields.  Non-string
+elements will be converted to string.
+"""
+            def writerows(self, rows: Iterable[Iterable[Any]]) -> None:
+                """writerows(iterable of iterables)
+
+Construct and write a series of iterables to a csv file.  Non-string
+elements will be converted to string.
+"""
 
     # For the return types below.
     # These aliases can be removed when typeshed drops support for 3.9.
@@ -104,7 +142,14 @@ def writer(
     lineterminator: str = "\r\n",
     quoting: _QuotingType = 0,
     strict: bool = False,
-) -> _writer: ...
+) -> _writer:
+    """Return a writer object that will write user data on the given file object.
+
+The "fileobj" argument can be any object that supports the file API.
+The optional "dialect" argument defines a CSV dialect.  The function
+also accepts optional keyword arguments which override settings
+provided by the dialect.
+"""
 def reader(
     iterable: Iterable[str],
     /,
@@ -118,7 +163,18 @@ def reader(
     lineterminator: str = "\r\n",
     quoting: _QuotingType = 0,
     strict: bool = False,
-) -> _reader: ...
+) -> _reader:
+    """Return a reader object that will process lines from the given iterable.
+
+The "iterable" argument can be any object that returns a line
+of input for each iteration, such as a file object or a list.  The
+optional "dialect" argument defines a CSV dialect.  The function
+also accepts optional keyword arguments which override settings
+provided by the dialect.
+
+The returned object is an iterator.  Each iteration returns a row
+of the CSV file (which can span multiple input lines).
+"""
 def register_dialect(
     name: str,
     /,
@@ -132,8 +188,26 @@ def register_dialect(
     lineterminator: str = "\r\n",
     quoting: _QuotingType = 0,
     strict: bool = False,
-) -> None: ...
+) -> None:
-def unregister_dialect(name: str) -> None: ...
+    """Create a mapping from a string name to a CVS dialect.
-def get_dialect(name: str) -> Dialect: ...
+
-def list_dialects() -> list[str]: ...
+The optional "dialect" argument specifies the base dialect instance
-def field_size_limit(new_limit: int = ...) -> int: ...
+or the name of the registered dialect.  The function also accepts
+optional keyword arguments which override settings provided by the
+dialect.
+"""
+def unregister_dialect(name: str) -> None:
+    """Delete the name/dialect mapping associated with a string name.
+"""
+def get_dialect(name: str) -> Dialect:
+    """Return the dialect instance associated with name.
+"""
+def list_dialects() -> list[str]:
+    """Return a list of all known dialect names.
+"""
+def field_size_limit(new_limit: int = ...) -> int:
+    """Sets an upper limit on parsed fields.
+
+Returns old limit. If limit is not given, no new limit is set and
+the old limit is returned
+"""

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

@@ -1,3 +1,5 @@
+"""Create and manipulate C compatible data types in Python.
+"""
 import _typeshed
 import sys
 from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
@@ -47,10 +49,16 @@ if sys.platform == "win32":
     def FreeLibrary(handle: int, /) -> None: ...
 
 else:
-    def dlclose(handle: int, /) -> None: ...
+    def dlclose(handle: int, /) -> None:
+        """dlclose a library
+"""
     # The default for flag is RTLD_GLOBAL|RTLD_LOCAL, which is platform dependent.
-    def dlopen(name: StrOrBytesPath, flag: int = ..., /) -> int: ...
+    def dlopen(name: StrOrBytesPath, flag: int = ..., /) -> int:
-    def dlsym(handle: int, name: str, /) -> int: ...
+        """dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library
+"""
+    def dlsym(handle: int, name: str, /) -> int:
+        """find symbol in shared library
+"""
 
 if sys.version_info >= (3, 13):
     # This class is not exposed. It calls itself _ctypes.CType_Type.
@@ -97,6 +105,8 @@ class _PyCSimpleType(_CTypeBaseType):
         def __rmul__(self: type[_CT], value: int, /) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
 class _SimpleCData(_CData, Generic[_T], metaclass=_PyCSimpleType):
+    """XXX to be provided
+"""
     value: _T
     # The TypeVar can be unsolved here,
     # but we can't use overloads without creating many, many mypy false-positive errors
@@ -124,6 +134,8 @@ class _PyCPointerType(_CTypeBaseType):
         def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
 class _Pointer(_PointerLike, _CData, Generic[_CT], metaclass=_PyCPointerType):
+    """XXX to be provided
+"""
     _type_: type[_CT]
     contents: _CT
     @overload
@@ -131,17 +143,35 @@ class _Pointer(_PointerLike, _CData, Generic[_CT], metaclass=_PyCPointerType):
     @overload
     def __init__(self, arg: _CT) -> None: ...
     @overload
-    def __getitem__(self, key: int, /) -> Any: ...
+    def __getitem__(self, key: int, /) -> Any:
+        """Return self[key].
+"""
     @overload
     def __getitem__(self, key: slice, /) -> list[Any]: ...
-    def __setitem__(self, key: int, value: Any, /) -> None: ...
+    def __setitem__(self, key: int, value: Any, /) -> None:
+        """Set self[key] to value.
+"""
 
 if sys.version_info < (3, 14):
     @overload
-    def POINTER(type: None, /) -> type[c_void_p]: ...
+    def POINTER(type: None, /) -> type[c_void_p]:
+        """Create and return a new ctypes pointer type.
+
+  type
+    A ctypes type.
+
+Pointer types are cached and reused internally,
+so calling this function repeatedly is cheap.
+"""
     @overload
     def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]: ...
-    def pointer(obj: _CT, /) -> _Pointer[_CT]: ...
+    def pointer(obj: _CT, /) -> _Pointer[_CT]:
+        """Create a new pointer instance, pointing to 'obj'.
+
+The returned object is of the type POINTER(type(obj)). Note that if you
+just want to pass a pointer to an object to a foreign function call, you
+should use byref(obj) which is much faster.
+"""
 
 # This class is not exposed. It calls itself _ctypes.CArgObject.
 @final
@@ -149,10 +179,16 @@ if sys.version_info < (3, 14):
 class _CArgObject: ...
 
 if sys.version_info >= (3, 14):
-    def byref(obj: _CData | _CDataType, offset: int = 0, /) -> _CArgObject: ...
+    def byref(obj: _CData | _CDataType, offset: int = 0, /) -> _CArgObject:
+        """Return a pointer lookalike to a C instance, only usable as function argument.
+"""
 
 else:
-    def byref(obj: _CData | _CDataType, offset: int = 0) -> _CArgObject: ...
+    def byref(obj: _CData | _CDataType, offset: int = 0) -> _CArgObject:
+        """byref(C instance[, offset=0]) -> byref-object
+Return a pointer lookalike to a C instance, only usable
+as function argument
+"""
 
 _ECT: TypeAlias = Callable[[_CData | _CDataType | None, CFuncPtr, tuple[_CData | _CDataType, ...]], _CDataType]
 _PF: TypeAlias = tuple[int] | tuple[int, str | None] | tuple[int, str | None, Any]
@@ -171,6 +207,8 @@ class _PyCFuncPtrType(_CTypeBaseType):
         def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
 class CFuncPtr(_PointerLike, _CData, metaclass=_PyCFuncPtrType):
+    """Function Pointer
+"""
     restype: type[_CDataType] | Callable[[int], Any] | None
     argtypes: Sequence[type[_CDataType]]
     errcheck: _ECT
@@ -190,7 +228,9 @@ class CFuncPtr(_PointerLike, _CData, metaclass=_PyCFuncPtrType):
             cls, vtbl_index: int, name: str, paramflags: tuple[_PF, ...] | None = ..., iid: _CData | _CDataType | None = ..., /
         ) -> Self: ...
 
-    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Call self as a function.
+"""
 
 _GetT = TypeVar("_GetT")
 _SetT = TypeVar("_SetT")
@@ -232,6 +272,8 @@ class _UnionType(_CTypeBaseType):
         def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
 class Union(_CData, metaclass=_UnionType):
+    """Union base class
+"""
     _fields_: ClassVar[Sequence[tuple[str, type[_CDataType]] | tuple[str, type[_CDataType], int]]]
     _pack_: ClassVar[int]
     _anonymous_: ClassVar[Sequence[str]]
@@ -260,6 +302,8 @@ class _PyCStructType(_CTypeBaseType):
         def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
 class Structure(_CData, metaclass=_PyCStructType):
+    """Structure base class
+"""
     _fields_: ClassVar[Sequence[tuple[str, type[_CDataType]] | tuple[str, type[_CDataType], int]]]
     _pack_: ClassVar[int]
     _anonymous_: ClassVar[Sequence[str]]
@@ -288,6 +332,14 @@ class _PyCArrayType(_CTypeBaseType):
         def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
 class Array(_CData, Generic[_CT], metaclass=_PyCArrayType):
+    """Abstract base class for arrays.
+
+The recommended way to create concrete array types is by multiplying any
+ctypes data type with a non-negative integer. Alternatively, you can subclass
+this type and define _length_ and _type_ class variables. Array elements can
+be read and written using standard subscript and slice accesses for slice
+reads, the resulting object is not itself an Array.
+"""
     @property
     @abstractmethod
     def _length_(self) -> int: ...
@@ -318,28 +370,48 @@ class Array(_CData, Generic[_CT], metaclass=_PyCArrayType):
     # the array element type would belong are annotated with Any instead.
     def __init__(self, *args: Any) -> None: ...
     @overload
-    def __getitem__(self, key: int, /) -> Any: ...
+    def __getitem__(self, key: int, /) -> Any:
+        """Return self[key].
+"""
     @overload
     def __getitem__(self, key: slice, /) -> list[Any]: ...
     @overload
-    def __setitem__(self, key: int, value: Any, /) -> None: ...
+    def __setitem__(self, key: int, value: Any, /) -> None:
+        """Set self[key] to value.
+"""
     @overload
     def __setitem__(self, key: slice, value: Iterable[Any], /) -> None: ...
     def __iter__(self) -> Iterator[Any]: ...
     # Can't inherit from Sized because the metaclass conflict between
     # Sized and _CData prevents using _CDataMeta.
-    def __len__(self) -> int: ...
+    def __len__(self) -> int:
-    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        """Return len(self).
+"""
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+        """See PEP 585
+"""
 
-def addressof(obj: _CData | _CDataType, /) -> int: ...
+def addressof(obj: _CData | _CDataType, /) -> int:
-def alignment(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...
+    """Return the address of the C instance internal buffer
+"""
+def alignment(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int:
+    """alignment(C type) -> integer
+alignment(C instance) -> integer
+Return the alignment requirements of a C instance
+"""
 def get_errno() -> int: ...
-def resize(obj: _CData | _CDataType, size: int, /) -> None: ...
+def resize(obj: _CData | _CDataType, size: int, /) -> None:
+    """Resize the memory buffer of a ctypes instance
+"""
 def set_errno(value: int, /) -> int: ...
-def sizeof(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...
+def sizeof(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int:
+    """Return the size in bytes of a C instance.
+"""
 def PyObj_FromPtr(address: int, /) -> Any: ...
 def Py_DECREF(o: _T, /) -> _T: ...
 def Py_INCREF(o: _T, /) -> _T: ...
-def buffer_info(o: _CData | _CDataType | type[_CData | _CDataType], /) -> tuple[str, int, tuple[int, ...]]: ...
+def buffer_info(o: _CData | _CDataType | type[_CData | _CDataType], /) -> tuple[str, int, tuple[int, ...]]:
+    """Return buffer interface information
+"""
 def call_cdeclfunction(address: int, arguments: tuple[Any, ...], /) -> Any: ...
 def call_function(address: int, arguments: tuple[Any, ...], /) -> Any: ...

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

@@ -8,20 +8,56 @@ class error(Exception): ...
 
 @final
 class panel:
-    def above(self) -> panel: ...
+    def above(self) -> panel:
-    def below(self) -> panel: ...
+        """Return the panel above the current panel.
-    def bottom(self) -> None: ...
+"""
-    def hidden(self) -> bool: ...
+    def below(self) -> panel:
-    def hide(self) -> None: ...
+        """Return the panel below the current panel.
-    def move(self, y: int, x: int, /) -> None: ...
+"""
-    def replace(self, win: window, /) -> None: ...
+    def bottom(self) -> None:
-    def set_userptr(self, obj: object, /) -> None: ...
+        """Push the panel to the bottom of the stack.
-    def show(self) -> None: ...
+"""
-    def top(self) -> None: ...
+    def hidden(self) -> bool:
-    def userptr(self) -> object: ...
+        """Return True if the panel is hidden (not visible), False otherwise.
-    def window(self) -> window: ...
+"""
+    def hide(self) -> None:
+        """Hide the panel.
 
-def bottom_panel() -> panel: ...
+This does not delete the object, it just makes the window on screen invisible.
-def new_panel(win: window, /) -> panel: ...
+"""
-def top_panel() -> panel: ...
+    def move(self, y: int, x: int, /) -> None:
-def update_panels() -> panel: ...
+        """Move the panel to the screen coordinates (y, x).
+"""
+    def replace(self, win: window, /) -> None:
+        """Change the window associated with the panel to the window win.
+"""
+    def set_userptr(self, obj: object, /) -> None:
+        """Set the panel's user pointer to obj.
+"""
+    def show(self) -> None:
+        """Display the panel (which might have been hidden).
+"""
+    def top(self) -> None:
+        """Push panel to the top of the stack.
+"""
+    def userptr(self) -> object:
+        """Return the user pointer for the panel.
+"""
+    def window(self) -> window:
+        """Return the window object associated with the panel.
+"""
+
+def bottom_panel() -> panel:
+    """Return the bottom panel in the panel stack.
+"""
+def new_panel(win: window, /) -> panel:
+    """Return a panel object, associating it with the given window win.
+"""
+def top_panel() -> panel:
+    """Return the top panel in the panel stack.
+"""
+def update_panels() -> panel:
+    """Updates the virtual screen after changes in the panel stack.
+
+This does not call curses.doupdate(), so you'll have to do this yourself.
+"""

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

@@ -39,6 +39,26 @@ if sys.platform != "win32":
         __init__: None  # type: ignore[assignment]
 
     if sys.version_info >= (3, 11):
-        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...
+        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _dbm:
+            """Return a database object.
+
+  filename
+    The filename to open.
+  flags
+    How to open the file.  "r" for reading, "w" for writing, etc.
+  mode
+    If creating a new file, the mode bits for the new file
+    (e.g. os.O_RDWR).
+"""
     else:
-        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...
+        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm:
+            """Return a database object.
+
+  filename
+    The filename to open.
+  flags
+    How to open the file.  "r" for reading, "w" for writing, etc.
+  mode
+    If creating a new file, the mode bits for the new file
+    (e.g. os.O_RDWR).
+"""

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

@@ -1,3 +1,5 @@
+"""C decimal arithmetic module
+"""
 import sys
 from decimal import (
     Clamped as Clamped,
@@ -44,8 +46,14 @@ MIN_ETINY: Final[int]
 if sys.version_info >= (3, 14):
     IEEE_CONTEXT_MAX_BITS: Final[int]
 
-def setcontext(context: Context, /) -> None: ...
+def setcontext(context: Context, /) -> None:
-def getcontext() -> Context: ...
+    """Set a new default context.
+
+"""
+def getcontext() -> Context:
+    """Get the current default context.
+
+"""
 
 if sys.version_info >= (3, 11):
     def localcontext(
@@ -59,13 +67,30 @@ if sys.version_info >= (3, 11):
         clamp: int | None = None,
         traps: dict[_TrapType, bool] | None = None,
         flags: dict[_TrapType, bool] | None = None,
-    ) -> _ContextManager: ...
+    ) -> _ContextManager:
+        """Return a context manager that will set the default context to a copy of ctx
+on entry to the with-statement and restore the previous default context when
+exiting the with-statement. If no context is specified, a copy of the current
+default context is used.
+
+"""
 
 else:
-    def localcontext(ctx: Context | None = None) -> _ContextManager: ...
+    def localcontext(ctx: Context | None = None) -> _ContextManager:
+        """Return a context manager that will set the default context to a copy of ctx
+on entry to the with-statement and restore the previous default context when
+exiting the with-statement. If no context is specified, a copy of the current
+default context is used.
+
+"""
 
 if sys.version_info >= (3, 14):
-    def IEEEContext(bits: int, /) -> Context: ...
+    def IEEEContext(bits: int, /) -> Context:
+        """Return a context object initialized to the proper values for one of the
+IEEE interchange formats.  The argument must be a multiple of 32 and less
+than IEEE_CONTEXT_MAX_BITS.
+
+"""
 
 DefaultContext: Context
 BasicContext: Context

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

@@ -1,3 +1,11 @@
+"""Core implementation of import.
+
+This module is NOT meant to be directly imported! It has been designed such
+that it can be bootstrapped into Python as the implementation of import. As
+such it requires the injection of specific modules and attributes in order to
+work. One should use importlib as the public-facing version of this module.
+
+"""
 import importlib.abc
 import importlib.machinery
 import sys
@@ -15,16 +23,65 @@ def __import__(
     locals: Mapping[str, object] | None = None,
     fromlist: Sequence[str] | None = (),
     level: int = 0,
-) -> ModuleType: ...
+) -> ModuleType:
+    """Import a module.
+
+The 'globals' argument is used to infer where the import is occurring from
+to handle relative imports. The 'locals' argument is ignored. The
+'fromlist' argument specifies what should exist as attributes on the module
+being imported (e.g. ``from module import <fromlist>``).  The 'level'
+argument represents the package location to import from in a relative
+import (e.g. ``from ..pkg import mod`` would have a 'level' of 2).
+
+"""
 def spec_from_loader(
     name: str, loader: LoaderProtocol | None, *, origin: str | None = None, is_package: bool | None = None
-) -> importlib.machinery.ModuleSpec | None: ...
+) -> importlib.machinery.ModuleSpec | None:
-def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
+    """Return a module spec based on various loader methods.
+"""
+def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType:
+    """Create a module based on the provided spec.
+"""
 def _init_module_attrs(
     spec: importlib.machinery.ModuleSpec, module: types.ModuleType, *, override: bool = False
 ) -> types.ModuleType: ...
 
 class ModuleSpec:
+    """The specification for a module, used for loading.
+
+A module's spec is the source for information about the module.  For
+data associated with the module, including source, use the spec's
+loader.
+
+`name` is the absolute name of the module.  `loader` is the loader
+to use when loading the module.  `parent` is the name of the
+package the module is in.  The parent is derived from the name.
+
+`is_package` determines if the module is considered a package or
+not.  On modules this is reflected by the `__path__` attribute.
+
+`origin` is the specific location used by the loader from which to
+load the module, if that information is available.  When filename is
+set, origin will match.
+
+`has_location` indicates that a spec's "origin" reflects a location.
+When this is True, `__file__` attribute of the module is set.
+
+`cached` is the location of the cached bytecode file, if any.  It
+corresponds to the `__cached__` attribute.
+
+`submodule_search_locations` is the sequence of path entries to
+search when importing submodules.  If set, is_package should be
+True--and False otherwise.
+
+Packages are simply modules that (may) have submodules.  If a spec
+has a non-None value in `submodule_search_locations`, the import
+system will consider modules loaded from the spec as packages.
+
+Only finders (see importlib.abc.MetaPathFinder and
+importlib.abc.PathEntryFinder) should modify ModuleSpec instances.
+
+"""
     def __init__(
         self,
         name: str,
@@ -41,17 +98,32 @@ class ModuleSpec:
     loader_state: Any
     cached: str | None
     @property
-    def parent(self) -> str | None: ...
+    def parent(self) -> str | None:
+        """The name of the module's parent.
+"""
     has_location: bool
     def __eq__(self, other: object) -> bool: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
+    """Meta path import for built-in modules.
+
+All methods are either class or static methods to avoid the need to
+instantiate the class.
+
+"""
     # MetaPathFinder
     if sys.version_info < (3, 12):
         @classmethod
         @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `find_spec()` instead.")
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None:
+            """Find the built-in module.
+
+        If 'path' is ever specified then the search is considered a failure.
+
+        This method is deprecated.  Use find_spec() instead.
+
+        """
 
     @classmethod
     def find_spec(
@@ -59,13 +131,24 @@ class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader)
     ) -> ModuleSpec | None: ...
     # InspectLoader
     @classmethod
-    def is_package(cls, fullname: str) -> bool: ...
+    def is_package(cls, fullname: str) -> bool:
+        """Return False as built-in modules are never packages.
+"""
     @classmethod
-    def load_module(cls, fullname: str) -> types.ModuleType: ...
+    def load_module(cls, fullname: str) -> types.ModuleType:
+        """Load the specified module into sys.modules and return it.
+
+This method is deprecated.  Use loader.exec_module() instead.
+
+"""
     @classmethod
-    def get_code(cls, fullname: str) -> None: ...
+    def get_code(cls, fullname: str) -> None:
+        """Return None as built-in modules do not have code objects.
+"""
     @classmethod
-    def get_source(cls, fullname: str) -> None: ...
+    def get_source(cls, fullname: str) -> None:
+        """Return None as built-in modules do not have source code.
+"""
     # Loader
     if sys.version_info < (3, 12):
         @staticmethod
@@ -73,24 +156,48 @@ class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader)
             "Deprecated since Python 3.4; removed in Python 3.12. "
             "The module spec is now used by the import machinery to generate a module repr."
         )
-        def module_repr(module: types.ModuleType) -> str: ...
+        def module_repr(module: types.ModuleType) -> str:
+            """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
     if sys.version_info >= (3, 10):
         @staticmethod
-        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
+        def create_module(spec: ModuleSpec) -> types.ModuleType | None:
+            """Create a built-in module
+"""
         @staticmethod
-        def exec_module(module: types.ModuleType) -> None: ...
+        def exec_module(module: types.ModuleType) -> None:
+            """Exec a built-in module
+"""
     else:
         @classmethod
-        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
+        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None:
+            """Create a built-in module
+"""
         @classmethod
-        def exec_module(cls, module: types.ModuleType) -> None: ...
+        def exec_module(cls, module: types.ModuleType) -> None:
+            """Exec a built-in module
+"""
 
 class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
+    """Meta path import for frozen modules.
+
+All methods are either class or static methods to avoid the need to
+instantiate the class.
+
+"""
     # MetaPathFinder
     if sys.version_info < (3, 12):
         @classmethod
         @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `find_spec()` instead.")
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None:
+            """Find a frozen module.
+
+        This method is deprecated.  Use find_spec() instead.
+
+        """
 
     @classmethod
     def find_spec(
@@ -98,13 +205,24 @@ class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
     ) -> ModuleSpec | None: ...
     # InspectLoader
     @classmethod
-    def is_package(cls, fullname: str) -> bool: ...
+    def is_package(cls, fullname: str) -> bool:
+        """Return True if the frozen module is a package.
+"""
     @classmethod
-    def load_module(cls, fullname: str) -> types.ModuleType: ...
+    def load_module(cls, fullname: str) -> types.ModuleType:
+        """Load a frozen module.
+
+This method is deprecated.  Use exec_module() instead.
+
+"""
     @classmethod
-    def get_code(cls, fullname: str) -> None: ...
+    def get_code(cls, fullname: str) -> None:
+        """Return the code object for the frozen module.
+"""
     @classmethod
-    def get_source(cls, fullname: str) -> None: ...
+    def get_source(cls, fullname: str) -> None:
+        """Return None as frozen modules do not have source code.
+"""
     # Loader
     if sys.version_info < (3, 12):
         @staticmethod
@@ -112,13 +230,22 @@ class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
             "Deprecated since Python 3.4; removed in Python 3.12. "
             "The module spec is now used by the import machinery to generate a module repr."
         )
-        def module_repr(m: types.ModuleType) -> str: ...
+        def module_repr(m: types.ModuleType) -> str:
+            """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
     if sys.version_info >= (3, 10):
         @staticmethod
-        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
+        def create_module(spec: ModuleSpec) -> types.ModuleType | None:
+            """Set __file__, if able.
+"""
     else:
         @classmethod
-        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
+        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None:
+            """Use default semantics for module creation.
+"""
 
     @staticmethod
     def exec_module(module: types.ModuleType) -> None: ...

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

@@ -1,3 +1,11 @@
+"""Core implementation of path-based import.
+
+This module is NOT meant to be directly imported! It has been designed such
+that it can be bootstrapped into Python as the implementation of import. As
+such it requires the injection of specific modules and attributes in order to
+work. One should use importlib as the public-facing version of this module.
+
+"""
 import _ast
 import _io
 import importlib.abc
@@ -26,25 +34,71 @@ else:
 
 MAGIC_NUMBER: Final[bytes]
 
-def cache_from_source(path: StrPath, debug_override: bool | None = None, *, optimization: Any | None = None) -> str: ...
+def cache_from_source(path: StrPath, debug_override: bool | None = None, *, optimization: Any | None = None) -> str:
-def source_from_cache(path: StrPath) -> str: ...
+    """Given the path to a .py file, return the path to its .pyc file.
-def decode_source(source_bytes: ReadableBuffer) -> str: ...
+
+The .py file does not need to exist; this simply returns the path to the
+.pyc file calculated as if the .py file were imported.
+
+The 'optimization' parameter controls the presumed optimization level of
+the bytecode file. If 'optimization' is not None, the string representation
+of the argument is taken and verified to be alphanumeric (else ValueError
+is raised).
+
+The debug_override parameter is deprecated. If debug_override is not None,
+a True value is the same as setting 'optimization' to the empty string
+while a False value is equivalent to setting 'optimization' to '1'.
+
+If sys.implementation.cache_tag is None then NotImplementedError is raised.
+
+"""
+def source_from_cache(path: StrPath) -> str:
+    """Given the path to a .pyc. file, return the path to its .py file.
+
+The .pyc file does not need to exist; this simply returns the path to
+the .py file calculated to correspond to the .pyc file.  If path does
+not conform to PEP 3147/488 format, ValueError will be raised. If
+sys.implementation.cache_tag is None then NotImplementedError is raised.
+
+"""
+def decode_source(source_bytes: ReadableBuffer) -> str:
+    """Decode bytes representing source code and return the string.
+
+Universal newline support is used in the decoding.
+"""
 def spec_from_file_location(
     name: str,
     location: StrOrBytesPath | None = None,
     *,
     loader: LoaderProtocol | None = None,
     submodule_search_locations: list[str] | None = ...,
-) -> importlib.machinery.ModuleSpec | None: ...
+) -> importlib.machinery.ModuleSpec | None:
+    """Return a module spec based on a file location.
+
+To indicate that the module is a package, set
+submodule_search_locations to a list of directory paths.  An
+empty list is sufficient, though its not otherwise useful to the
+import system.
+
+The loader must take a spec as its only __init__() arg.
+
+"""
 @deprecated(
     "Deprecated since Python 3.6. Use site configuration instead. "
     "Future versions of Python may not enable this finder by default."
 )
 class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
+    """Meta path finder for modules declared in the Windows registry.
+"""
     if sys.version_info < (3, 12):
         @classmethod
         @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `find_spec()` instead.")
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None:
+            """Find module named in the registry.
+
+        This method is deprecated.  Use find_spec() instead.
+
+        """
 
     @classmethod
     def find_spec(
@@ -52,27 +106,61 @@ class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
     ) -> ModuleSpec | None: ...
 
 class PathFinder(importlib.abc.MetaPathFinder):
+    """Meta path finder for sys.path and package __path__ attributes.
+"""
     if sys.version_info >= (3, 10):
         @staticmethod
-        def invalidate_caches() -> None: ...
+        def invalidate_caches() -> None:
+            """Call the invalidate_caches() method on all path entry finders
+stored in sys.path_importer_cache (where implemented).
+"""
     else:
         @classmethod
-        def invalidate_caches(cls) -> None: ...
+        def invalidate_caches(cls) -> None:
+            """Call the invalidate_caches() method on all path entry finders
+        stored in sys.path_importer_caches (where implemented).
+"""
     if sys.version_info >= (3, 10):
         @staticmethod
-        def find_distributions(context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
+        def find_distributions(context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]:
+            """
+Find distributions.
+
+Return an iterable of all Distribution instances capable of
+loading the metadata for packages matching ``context.name``
+(or all names if ``None`` indicated) along the paths in the list
+of directories ``context.path``.
+"""
     else:
         @classmethod
-        def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
+        def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]:
+            """
+        Find distributions.
+
+        Return an iterable of all Distribution instances capable of
+        loading the metadata for packages matching ``context.name``
+        (or all names if ``None`` indicated) along the paths in the list
+        of directories ``context.path``.
+        """
 
     @classmethod
     def find_spec(
         cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
+    ) -> ModuleSpec | None:
+        """Try to find a spec for 'fullname' on sys.path or 'path'.
+
+The search is based on sys.path_hooks and sys.path_importer_cache.
+"""
     if sys.version_info < (3, 12):
         @classmethod
         @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `find_spec()` instead.")
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None:
+            """find the module on sys.path or 'path' based on sys.path_hooks and
+        sys.path_importer_cache.
+
+        This method is deprecated.  Use find_spec() instead.
+
+        """
 
 SOURCE_SUFFIXES: Final[list[str]]
 DEBUG_BYTECODE_SUFFIXES: Final = [".pyc"]
@@ -81,36 +169,113 @@ BYTECODE_SUFFIXES: Final = [".pyc"]
 EXTENSION_SUFFIXES: Final[list[str]]
 
 class FileFinder(importlib.abc.PathEntryFinder):
+    """File-based finder.
+
+Interactions with the file system are cached for performance, being
+refreshed when the directory the finder is handling has been modified.
+
+"""
     path: str
-    def __init__(self, path: str, *loader_details: tuple[type[importlib.abc.Loader], list[str]]) -> None: ...
+    def __init__(self, path: str, *loader_details: tuple[type[importlib.abc.Loader], list[str]]) -> None:
+        """Initialize with the path to search on and a variable number of
+2-tuples containing the loader and the file suffixes the loader
+recognizes.
+"""
     @classmethod
     def path_hook(
         cls, *loader_details: tuple[type[importlib.abc.Loader], list[str]]
-    ) -> Callable[[str], importlib.abc.PathEntryFinder]: ...
+    ) -> Callable[[str], importlib.abc.PathEntryFinder]:
+        """A class method which returns a closure to use on sys.path_hook
+which will return an instance using the specified loaders and the path
+called on the closure.
+
+If the path called on the closure is not a directory, ImportError is
+raised.
+
+"""
 
 class _LoaderBasics:
-    def is_package(self, fullname: str) -> bool: ...
+    """Base class of common code needed by both SourceLoader and
-    def create_module(self, spec: ModuleSpec) -> types.ModuleType | None: ...
+SourcelessFileLoader.
-    def exec_module(self, module: types.ModuleType) -> None: ...
+"""
-    def load_module(self, fullname: str) -> types.ModuleType: ...
+    def is_package(self, fullname: str) -> bool:
+        """Concrete implementation of InspectLoader.is_package by checking if
+the path returned by get_filename has a filename of '__init__.py'.
+"""
+    def create_module(self, spec: ModuleSpec) -> types.ModuleType | None:
+        """Use default semantics for module creation.
+"""
+    def exec_module(self, module: types.ModuleType) -> None:
+        """Execute the module.
+"""
+    def load_module(self, fullname: str) -> types.ModuleType:
+        """This method is deprecated.
+"""
 
 class SourceLoader(_LoaderBasics):
-    def path_mtime(self, path: str) -> float: ...
+    def path_mtime(self, path: str) -> float:
-    def set_data(self, path: str, data: bytes) -> None: ...
+        """Optional method that returns the modification time (an int) for the
-    def get_source(self, fullname: str) -> str | None: ...
+specified path (a str).
-    def path_stats(self, path: str) -> Mapping[str, Any]: ...
+
+Raises OSError when the path cannot be handled.
+"""
+    def set_data(self, path: str, data: bytes) -> None:
+        """Optional method which writes data (bytes) to a file path (a str).
+
+Implementing this method allows for the writing of bytecode files.
+"""
+    def get_source(self, fullname: str) -> str | None:
+        """Concrete implementation of InspectLoader.get_source.
+"""
+    def path_stats(self, path: str) -> Mapping[str, Any]:
+        """Optional method returning a metadata dict for the specified
+path (a str).
+
+Possible keys:
+- 'mtime' (mandatory) is the numeric timestamp of last source
+  code modification;
+- 'size' (optional) is the size in bytes of the source code.
+
+Implementing this method allows the loader to read bytecode files.
+Raises OSError when the path cannot be handled.
+"""
     def source_to_code(
         self, data: ReadableBuffer | str | _ast.Module | _ast.Expression | _ast.Interactive, path: bytes | StrPath
-    ) -> types.CodeType: ...
+    ) -> types.CodeType:
-    def get_code(self, fullname: str) -> types.CodeType | None: ...
+        """Return the code object compiled from source.
+
+The 'data' argument can be any object type that compile() supports.
+"""
+    def get_code(self, fullname: str) -> types.CodeType | None:
+        """Concrete implementation of InspectLoader.get_code.
+
+Reading of bytecode requires path_stats to be implemented. To write
+bytecode, set_data must also be implemented.
+
+"""
 
 class FileLoader:
+    """Base file loader class which implements the loader protocol methods that
+require file system usage.
+"""
     name: str
     path: str
-    def __init__(self, fullname: str, path: str) -> None: ...
+    def __init__(self, fullname: str, path: str) -> None:
-    def get_data(self, path: str) -> bytes: ...
+        """Cache the module name and the path to the file found by the
-    def get_filename(self, fullname: str | None = None) -> str: ...
+finder.
-    def load_module(self, fullname: str | None = None) -> types.ModuleType: ...
+"""
+    def get_data(self, path: str) -> bytes:
+        """Return the data from path as raw bytes.
+"""
+    def get_filename(self, fullname: str | None = None) -> str:
+        """Return the path to the source file as found by the finder.
+"""
+    def load_module(self, fullname: str | None = None) -> types.ModuleType:
+        """Load a module from a file.
+
+This method is deprecated.  Use exec_module() instead.
+
+"""
     if sys.version_info >= (3, 10):
         def get_resource_reader(self, name: str | None = None) -> importlib.readers.FileReader: ...
     else:
@@ -121,27 +286,56 @@ class FileLoader:
         def contents(self) -> Iterator[str]: ...
 
 class SourceFileLoader(importlib.abc.FileLoader, FileLoader, importlib.abc.SourceLoader, SourceLoader):  # type: ignore[misc]  # incompatible method arguments in base classes
-    def set_data(self, path: str, data: ReadableBuffer, *, _mode: int = 0o666) -> None: ...
+    """Concrete implementation of SourceLoader using the file system.
-    def path_stats(self, path: str) -> Mapping[str, Any]: ...
+"""
+    def set_data(self, path: str, data: ReadableBuffer, *, _mode: int = 0o666) -> None:
+        """Write bytes data to a file.
+"""
+    def path_stats(self, path: str) -> Mapping[str, Any]:
+        """Return the metadata for the path.
+"""
     def source_to_code(  # type: ignore[override]  # incompatible with InspectLoader.source_to_code
         self,
         data: ReadableBuffer | str | _ast.Module | _ast.Expression | _ast.Interactive,
         path: bytes | StrPath,
         *,
         _optimize: int = -1,
-    ) -> types.CodeType: ...
+    ) -> types.CodeType:
+        """Return the code object compiled from source.
+
+The 'data' argument can be any object type that compile() supports.
+"""
 
 class SourcelessFileLoader(importlib.abc.FileLoader, FileLoader, _LoaderBasics):
+    """Loader which handles sourceless file imports.
+"""
     def get_code(self, fullname: str) -> types.CodeType | None: ...
-    def get_source(self, fullname: str) -> None: ...
+    def get_source(self, fullname: str) -> None:
+        """Return None as there is no source code.
+"""
 
 class ExtensionFileLoader(FileLoader, _LoaderBasics, importlib.abc.ExecutionLoader):
+    """Loader for extension modules.
+
+The constructor is designed to work with FileFinder.
+
+"""
     def __init__(self, name: str, path: str) -> None: ...
-    def get_filename(self, fullname: str | None = None) -> str: ...
+    def get_filename(self, fullname: str | None = None) -> str:
-    def get_source(self, fullname: str) -> None: ...
+        """Return the path to the source file as found by the finder.
-    def create_module(self, spec: ModuleSpec) -> types.ModuleType: ...
+"""
-    def exec_module(self, module: types.ModuleType) -> None: ...
+    def get_source(self, fullname: str) -> None:
-    def get_code(self, fullname: str) -> None: ...
+        """Return None as extension modules have no source code.
+"""
+    def create_module(self, spec: ModuleSpec) -> types.ModuleType:
+        """Create an uninitialized extension module
+"""
+    def exec_module(self, module: types.ModuleType) -> None:
+        """Initialize an extension module
+"""
+    def get_code(self, fullname: str) -> None:
+        """Return None as an extension module cannot create a code object.
+"""
     def __eq__(self, other: object) -> bool: ...
     def __hash__(self) -> int: ...
 
@@ -153,10 +347,17 @@ if sys.version_info >= (3, 11):
         def is_package(self, fullname: str) -> Literal[True]: ...
         def get_source(self, fullname: str) -> Literal[""]: ...
         def get_code(self, fullname: str) -> types.CodeType: ...
-        def create_module(self, spec: ModuleSpec) -> None: ...
+        def create_module(self, spec: ModuleSpec) -> None:
+            """Use default semantics for module creation.
+"""
         def exec_module(self, module: types.ModuleType) -> None: ...
         @deprecated("Deprecated since Python 3.10; will be removed in Python 3.15. Use `exec_module()` instead.")
-        def load_module(self, fullname: str) -> types.ModuleType: ...
+        def load_module(self, fullname: str) -> types.ModuleType:
+            """Load a namespace module.
+
+This method is deprecated.  Use exec_module() instead.
+
+"""
         def get_resource_reader(self, module: types.ModuleType) -> importlib.readers.NamespaceReader: ...
         if sys.version_info < (3, 12):
             @staticmethod
@@ -164,7 +365,12 @@ if sys.version_info >= (3, 11):
                 "Deprecated since Python 3.4; removed in Python 3.12. "
                 "The module spec is now used by the import machinery to generate a module repr."
             )
-            def module_repr(module: types.ModuleType) -> str: ...
+            def module_repr(module: types.ModuleType) -> str:
+                """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
 
     _NamespaceLoader = NamespaceLoader
 else:
@@ -175,26 +381,51 @@ else:
         def is_package(self, fullname: str) -> Literal[True]: ...
         def get_source(self, fullname: str) -> Literal[""]: ...
         def get_code(self, fullname: str) -> types.CodeType: ...
-        def create_module(self, spec: ModuleSpec) -> None: ...
+        def create_module(self, spec: ModuleSpec) -> None:
+            """Use default semantics for module creation.
+"""
         def exec_module(self, module: types.ModuleType) -> None: ...
         if sys.version_info >= (3, 10):
             @deprecated("Deprecated since Python 3.10; will be removed in Python 3.15. Use `exec_module()` instead.")
-            def load_module(self, fullname: str) -> types.ModuleType: ...
+            def load_module(self, fullname: str) -> types.ModuleType:
+                """Load a namespace module.
+
+        This method is deprecated.  Use exec_module() instead.
+
+        """
             @staticmethod
             @deprecated(
                 "Deprecated since Python 3.4; removed in Python 3.12. "
                 "The module spec is now used by the import machinery to generate a module repr."
             )
-            def module_repr(module: types.ModuleType) -> str: ...
+            def module_repr(module: types.ModuleType) -> str:
+                """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
             def get_resource_reader(self, module: types.ModuleType) -> importlib.readers.NamespaceReader: ...
         else:
-            def load_module(self, fullname: str) -> types.ModuleType: ...
+            def load_module(self, fullname: str) -> types.ModuleType:
+                """Load a namespace module.
+
+        This method is deprecated.  Use exec_module() instead.
+
+        """
             @classmethod
             @deprecated(
                 "Deprecated since Python 3.4; removed in Python 3.12. "
                 "The module spec is now used by the import machinery to generate a module repr."
             )
-            def module_repr(cls, module: types.ModuleType) -> str: ...
+            def module_repr(cls, module: types.ModuleType) -> str:
+                """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
 
 if sys.version_info >= (3, 13):
-    class AppleFrameworkLoader(ExtensionFileLoader, importlib.abc.ExecutionLoader): ...
+    class AppleFrameworkLoader(ExtensionFileLoader, importlib.abc.ExecutionLoader):
+        """A loader for modules that have been packaged as frameworks for
+compatibility with Apple's iOS App Store policies.
+"""

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

@@ -1,3 +1,14 @@
+"""This module provides an interface to the GNU DBM (GDBM) library.
+
+This module is quite similar to the dbm module, but uses GDBM instead to
+provide some additional functionality.  Please note that the file formats
+created by GDBM and dbm are incompatible.
+
+GDBM objects behave like mappings (dictionaries), except that keys and
+values are always immutable bytes-like objects or strings.  Printing
+a GDBM object doesn't print the keys and values, and the items() and
+values() methods are not supported.
+"""
 import sys
 from _typeshed import ReadOnlyBuffer, StrOrBytesPath
 from types import TracebackType
@@ -43,6 +54,29 @@ if sys.platform != "win32":
         __init__: None  # type: ignore[assignment]
 
     if sys.version_info >= (3, 11):
-        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...
+        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _gdbm:
+            """Open a dbm database and return a dbm object.
+
+The filename argument is the name of the database file.
+
+The optional flags argument can be 'r' (to open an existing database
+for reading only -- default), 'w' (to open an existing database for
+reading and writing), 'c' (which creates the database if it doesn't
+exist), or 'n' (which always creates a new empty database).
+
+Some versions of gdbm support additional flags which must be
+appended to one of the flags described above.  The module constant
+'open_flags' is a string of valid additional flags.  The 'f' flag
+opens the database in fast mode; altered data will not automatically
+be written to the disk after every change.  This results in faster
+writes to the database, but may result in an inconsistent database
+if the program crashes while the database is still open.  Use the
+sync() method to force any unwritten data to be written to the disk.
+The 's' flag causes all database operations to be synchronized to
+disk.  The 'u' flag disables locking of the database file.
+
+The optional mode argument is the Unix mode of the file, used only
+when the database has to be created.  It defaults to octal 0o666.
+"""
     else:
         def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...

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

@@ -1,3 +1,5 @@
+"""OpenSSL interface for hashlib module
+"""
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Callable
@@ -24,104 +26,260 @@ class _HashObject(Protocol):
 
 @disjoint_base
 class HASH:
+    """A hash is an object used to calculate a checksum of a string of information.
+
+Methods:
+
+update() -- updates the current digest with an additional string
+digest() -- return the current digest value
+hexdigest() -- return the current digest as a string of hexadecimal digits
+copy() -- return a copy of the current hash object
+
+Attributes:
+
+name -- the hash algorithm being used by this object
+digest_size -- number of bytes in this hashes output
+"""
     @property
     def digest_size(self) -> int: ...
     @property
     def block_size(self) -> int: ...
     @property
     def name(self) -> str: ...
-    def copy(self) -> Self: ...
+    def copy(self) -> Self:
-    def digest(self) -> bytes: ...
+        """Return a copy of the hash object.
-    def hexdigest(self) -> str: ...
+"""
-    def update(self, obj: ReadableBuffer, /) -> None: ...
+    def digest(self) -> bytes:
+        """Return the digest value as a bytes object.
+"""
+    def hexdigest(self) -> str:
+        """Return the digest value as a string of hexadecimal digits.
+"""
+    def update(self, obj: ReadableBuffer, /) -> None:
+        """Update this hash object's state with the provided string.
+"""
 
 if sys.version_info >= (3, 10):
     class UnsupportedDigestmodError(ValueError): ...
 
 class HASHXOF(HASH):
-    def digest(self, length: int) -> bytes: ...  # type: ignore[override]
+    """A hash is an object used to calculate a checksum of a string of information.
-    def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
+
+Methods:
+
+update() -- updates the current digest with an additional string
+digest(length) -- return the current digest value
+hexdigest(length) -- return the current digest as a string of hexadecimal digits
+copy() -- return a copy of the current hash object
+
+Attributes:
+
+name -- the hash algorithm being used by this object
+digest_size -- number of bytes in this hashes output
+"""
+    def digest(self, length: int) -> bytes:  # type: ignore[override]
+        """Return the digest value as a bytes object.
+"""
+    def hexdigest(self, length: int) -> str:  # type: ignore[override]
+        """Return the digest value as a string of hexadecimal digits.
+"""
 
 @final
 class HMAC:
+    """The object used to calculate HMAC of a message.
+
+Methods:
+
+update() -- updates the current digest with an additional string
+digest() -- return the current digest value
+hexdigest() -- return the current digest as a string of hexadecimal digits
+copy() -- return a copy of the current hash object
+
+Attributes:
+
+name -- the name, including the hash algorithm used by this object
+digest_size -- number of bytes in digest() output
+"""
     @property
     def digest_size(self) -> int: ...
     @property
     def block_size(self) -> int: ...
     @property
     def name(self) -> str: ...
-    def copy(self) -> Self: ...
+    def copy(self) -> Self:
-    def digest(self) -> bytes: ...
+        """Return a copy ("clone") of the HMAC object.
-    def hexdigest(self) -> str: ...
+"""
-    def update(self, msg: ReadableBuffer) -> None: ...
+    def digest(self) -> bytes:
+        """Return the digest of the bytes passed to the update() method so far.
+"""
+    def hexdigest(self) -> str:
+        """Return hexadecimal digest of the bytes passed to the update() method so far.
+
+This may be used to exchange the value safely in email or other non-binary
+environments.
+"""
+    def update(self, msg: ReadableBuffer) -> None:
+        """Update the HMAC object with msg.
+"""
 
 @overload
-def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
+def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool:
+    """Return 'a == b'.
+
+This function uses an approach designed to prevent
+timing analysis, making it appropriate for cryptography.
+
+a and b must both be of the same type: either str (ASCII only),
+or any bytes-like object.
+
+Note: If a and b are of different lengths, or if an error occurs,
+a timing attack could theoretically reveal information about the
+types and lengths of a and b--but not their values.
+"""
 @overload
 def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
-def get_fips_mode() -> int: ...
+def get_fips_mode() -> int:
-def hmac_new(key: bytes | bytearray, msg: ReadableBuffer = b"", digestmod: _DigestMod = None) -> HMAC: ...
+    """Determine the OpenSSL FIPS mode of operation.
+
+For OpenSSL 3.0.0 and newer it returns the state of the default provider
+in the default OSSL context. It's not quite the same as FIPS_mode() but good
+enough for unittests.
+
+Effectively any non-zero return value indicates FIPS mode;
+values other than 1 may have additional significance.
+"""
+def hmac_new(key: bytes | bytearray, msg: ReadableBuffer = b"", digestmod: _DigestMod = None) -> HMAC:
+    """Return a new hmac object.
+"""
 
 if sys.version_info >= (3, 13):
     def new(
         name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Return a new hash object using the named algorithm.
+
+An optional string argument may be provided and will be
+automatically hashed.
+
+The MD5 and SHA1 algorithms are always supported.
+"""
     def openssl_md5(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a md5 hash object; optionally initialized with a string
+"""
     def openssl_sha1(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha1 hash object; optionally initialized with a string
+"""
     def openssl_sha224(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha224 hash object; optionally initialized with a string
+"""
     def openssl_sha256(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha256 hash object; optionally initialized with a string
+"""
     def openssl_sha384(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha384 hash object; optionally initialized with a string
+"""
     def openssl_sha512(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha512 hash object; optionally initialized with a string
+"""
     def openssl_sha3_224(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha3-224 hash object; optionally initialized with a string
+"""
     def openssl_sha3_256(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha3-256 hash object; optionally initialized with a string
+"""
     def openssl_sha3_384(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha3-384 hash object; optionally initialized with a string
+"""
     def openssl_sha3_512(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASH: ...
+    ) -> HASH:
+        """Returns a sha3-512 hash object; optionally initialized with a string
+"""
     def openssl_shake_128(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASHXOF: ...
+    ) -> HASHXOF:
+        """Returns a shake-128 variable hash object; optionally initialized with a string
+"""
     def openssl_shake_256(
         data: ReadableBuffer = b"", *, usedforsecurity: bool = True, string: ReadableBuffer | None = None
-    ) -> HASHXOF: ...
+    ) -> HASHXOF:
+        """Returns a shake-256 variable hash object; optionally initialized with a string
+"""
 
 else:
-    def new(name: str, string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def new(name: str, string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
-    def openssl_md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+        """Return a new hash object using the named algorithm.
-    def openssl_sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_shake_128(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
-    def openssl_shake_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
 
-def hmac_digest(key: bytes | bytearray, msg: ReadableBuffer, digest: str) -> bytes: ...
+An optional string argument may be provided and will be
+automatically hashed.
+
+The MD5 and SHA1 algorithms are always supported.
+"""
+    def openssl_md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a md5 hash object; optionally initialized with a string
+"""
+    def openssl_sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha1 hash object; optionally initialized with a string
+"""
+    def openssl_sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha224 hash object; optionally initialized with a string
+"""
+    def openssl_sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha256 hash object; optionally initialized with a string
+"""
+    def openssl_sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha384 hash object; optionally initialized with a string
+"""
+    def openssl_sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha512 hash object; optionally initialized with a string
+"""
+    def openssl_sha3_224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha3-224 hash object; optionally initialized with a string
+"""
+    def openssl_sha3_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha3-256 hash object; optionally initialized with a string
+"""
+    def openssl_sha3_384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha3-384 hash object; optionally initialized with a string
+"""
+    def openssl_sha3_512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH:
+        """Returns a sha3-512 hash object; optionally initialized with a string
+"""
+    def openssl_shake_128(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF:
+        """Returns a shake-128 variable hash object; optionally initialized with a string
+"""
+    def openssl_shake_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF:
+        """Returns a shake-256 variable hash object; optionally initialized with a string
+"""
+
+def hmac_digest(key: bytes | bytearray, msg: ReadableBuffer, digest: str) -> bytes:
+    """Single-shot HMAC.
+"""
 def pbkdf2_hmac(
     hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: int | None = None
-) -> bytes: ...
+) -> bytes:
+    """Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function.
+"""
 def scrypt(
     password: ReadableBuffer, *, salt: ReadableBuffer, n: int, r: int, p: int, maxmem: int = 0, dklen: int = 64
-) -> bytes: ...
+) -> bytes:
+    """scrypt password-based key derivation function.
+"""

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

@@ -1,18 +1,81 @@
+"""Heap queue algorithm (a.k.a. priority queue).
+
+Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
+all k, counting elements from 0.  For the sake of comparison,
+non-existing elements are considered to be infinite.  The interesting
+property of a heap is that a[0] is always its smallest element.
+
+Usage:
+
+heap = []            # creates an empty heap
+heappush(heap, item) # pushes a new item on the heap
+item = heappop(heap) # pops the smallest item from the heap
+item = heap[0]       # smallest item on the heap without popping it
+heapify(x)           # transforms list into a heap, in-place, in linear time
+item = heapreplace(heap, item) # pops and returns smallest item, and adds
+                               # new item; the heap size is unchanged
+
+Our API differs from textbook heap algorithms as follows:
+
+- We use 0-based indexing.  This makes the relationship between the
+  index for a node and the indexes for its children slightly less
+  obvious, but is more suitable since Python uses 0-based indexing.
+
+- Our heappop() method returns the smallest item, not the largest.
+
+These two make it possible to view the heap as a regular Python list
+without surprises: heap[0] is the smallest item, and heap.sort()
+maintains the heap invariant!
+"""
 import sys
 from _typeshed import SupportsRichComparisonT as _T  # All type variable use in this module requires comparability.
 from typing import Final
 
 __about__: Final[str]
 
-def heapify(heap: list[_T], /) -> None: ...
+def heapify(heap: list[_T], /) -> None:
-def heappop(heap: list[_T], /) -> _T: ...
+    """Transform list into a heap, in-place, in O(len(heap)) time.
-def heappush(heap: list[_T], item: _T, /) -> None: ...
+"""
-def heappushpop(heap: list[_T], item: _T, /) -> _T: ...
+def heappop(heap: list[_T], /) -> _T:
-def heapreplace(heap: list[_T], item: _T, /) -> _T: ...
+    """Pop the smallest item off the heap, maintaining the heap invariant.
+"""
+def heappush(heap: list[_T], item: _T, /) -> None:
+    """Push item onto heap, maintaining the heap invariant.
+"""
+def heappushpop(heap: list[_T], item: _T, /) -> _T:
+    """Push item on the heap, then pop and return the smallest item from the heap.
+
+The combined action runs more efficiently than heappush() followed by
+a separate call to heappop().
+"""
+def heapreplace(heap: list[_T], item: _T, /) -> _T:
+    """Pop and return the current smallest value, and add the new item.
+
+This is more efficient than heappop() followed by heappush(), and can be
+more appropriate when using a fixed-size heap.  Note that the value
+returned may be larger than item!  That constrains reasonable uses of
+this routine unless written as part of a conditional replacement:
+
+    if item > heap[0]:
+        item = heapreplace(heap, item)
+"""
 
 if sys.version_info >= (3, 14):
-    def heapify_max(heap: list[_T], /) -> None: ...
+    def heapify_max(heap: list[_T], /) -> None:
-    def heappop_max(heap: list[_T], /) -> _T: ...
+        """Maxheap variant of heapify.
-    def heappush_max(heap: list[_T], item: _T, /) -> None: ...
+"""
-    def heappushpop_max(heap: list[_T], item: _T, /) -> _T: ...
+    def heappop_max(heap: list[_T], /) -> _T:
-    def heapreplace_max(heap: list[_T], item: _T, /) -> _T: ...
+        """Maxheap variant of heappop.
+"""
+    def heappush_max(heap: list[_T], item: _T, /) -> None:
+        """Push item onto max heap, maintaining the heap invariant.
+"""
+    def heappushpop_max(heap: list[_T], item: _T, /) -> _T:
+        """Maxheap variant of heappushpop.
+
+The combined action runs more efficiently than heappush_max() followed by
+a separate call to heappop_max().
+"""
+    def heapreplace_max(heap: list[_T], item: _T, /) -> _T:
+        """Maxheap variant of heapreplace.
+"""

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

@@ -1,3 +1,5 @@
+"""(Extremely) low-level import machinery bits as used by importlib.
+"""
 import sys
 import types
 from _typeshed import ReadableBuffer
@@ -9,22 +11,67 @@ if sys.version_info >= (3, 14):
     pyc_magic_number_token: int
 
 def source_hash(key: int, source: ReadableBuffer) -> bytes: ...
-def create_builtin(spec: ModuleSpec, /) -> types.ModuleType: ...
+def create_builtin(spec: ModuleSpec, /) -> types.ModuleType:
-def create_dynamic(spec: ModuleSpec, file: Any = None, /) -> types.ModuleType: ...
+    """Create an extension module.
-def acquire_lock() -> None: ...
+"""
-def exec_builtin(mod: types.ModuleType, /) -> int: ...
+def create_dynamic(spec: ModuleSpec, file: Any = None, /) -> types.ModuleType:
-def exec_dynamic(mod: types.ModuleType, /) -> int: ...
+    """Create an extension module.
-def extension_suffixes() -> list[str]: ...
+"""
-def init_frozen(name: str, /) -> types.ModuleType: ...
+def acquire_lock() -> None:
-def is_builtin(name: str, /) -> int: ...
+    """Acquires the interpreter's import lock for the current thread.
-def is_frozen(name: str, /) -> bool: ...
+
-def is_frozen_package(name: str, /) -> bool: ...
+This lock should be used by import hooks to ensure thread-safety when importing
-def lock_held() -> bool: ...
+modules. On platforms without threads, this function does nothing.
-def release_lock() -> None: ...
+"""
+def exec_builtin(mod: types.ModuleType, /) -> int:
+    """Initialize a built-in module.
+"""
+def exec_dynamic(mod: types.ModuleType, /) -> int:
+    """Initialize an extension module.
+"""
+def extension_suffixes() -> list[str]:
+    """Returns the list of file suffixes used to identify extension modules.
+"""
+def init_frozen(name: str, /) -> types.ModuleType:
+    """Initializes a frozen module.
+"""
+def is_builtin(name: str, /) -> int:
+    """Returns True if the module name corresponds to a built-in module.
+"""
+def is_frozen(name: str, /) -> bool:
+    """Returns True if the module name corresponds to a frozen module.
+"""
+def is_frozen_package(name: str, /) -> bool:
+    """Returns True if the module name is of a frozen package.
+"""
+def lock_held() -> bool:
+    """Return True if the import lock is currently held, else False.
+
+On platforms without threads, return False.
+"""
+def release_lock() -> None:
+    """Release the interpreter's import lock.
+
+On platforms without threads, this function does nothing.
+"""
 
 if sys.version_info >= (3, 11):
-    def find_frozen(name: str, /, *, withdata: bool = False) -> tuple[memoryview | None, bool, str | None] | None: ...
+    def find_frozen(name: str, /, *, withdata: bool = False) -> tuple[memoryview | None, bool, str | None] | None:
-    def get_frozen_object(name: str, data: ReadableBuffer | None = None, /) -> types.CodeType: ...
+        """Return info about the corresponding frozen module (if there is one) or None.
+
+The returned info (a 2-tuple):
+
+ * data         the raw marshalled bytes
+ * is_package   whether or not it is a package
+ * origname     the originally frozen module's name, or None if not
+                a stdlib module (this will usually be the same as
+                the module's current name)
+"""
+    def get_frozen_object(name: str, data: ReadableBuffer | None = None, /) -> types.CodeType:
+        """Create a code object for a frozen module.
+"""
 
 else:
-    def get_frozen_object(name: str, /) -> types.CodeType: ...
+    def get_frozen_object(name: str, /) -> types.CodeType:
+        """Create a code object for a frozen module.
+"""

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

@@ -1,3 +1,6 @@
+"""This module provides primitive operations to manage Python interpreters.
+The 'interpreters' module provides a more convenient interface.
+"""
 from _typeshed import structseq
 from typing import Any, Final, Literal, SupportsIndex, final
 from typing_extensions import Buffer, Self
@@ -11,24 +14,40 @@ class ChannelNotFoundError(ChannelError): ...
 # Mark as final, since instantiating ChannelID is not supported.
 @final
 class ChannelID:
+    """A channel ID identifies a channel and may be used as an int.
+"""
     @property
-    def end(self) -> Literal["send", "recv", "both"]: ...
+    def end(self) -> Literal["send", "recv", "both"]:
+        """'send', 'recv', or 'both'
+"""
     @property
-    def send(self) -> Self: ...
+    def send(self) -> Self:
+        """the 'send' end of the channel
+"""
     @property
-    def recv(self) -> Self: ...
+    def recv(self) -> Self:
+        """the 'recv' end of the channel
+"""
     def __eq__(self, other: object, /) -> bool: ...
     def __ge__(self, other: ChannelID, /) -> bool: ...
     def __gt__(self, other: ChannelID, /) -> bool: ...
     def __hash__(self) -> int: ...
-    def __index__(self) -> int: ...
+    def __index__(self) -> int:
-    def __int__(self) -> int: ...
+        """Return self converted to an integer, if self is suitable for use as an index into a list.
+"""
+    def __int__(self) -> int:
+        """int(self)
+"""
     def __le__(self, other: ChannelID, /) -> bool: ...
     def __lt__(self, other: ChannelID, /) -> bool: ...
     def __ne__(self, other: object, /) -> bool: ...
 
 @final
 class ChannelInfo(structseq[int], tuple[bool, bool, bool, int, int, int, int, int]):
+    """ChannelInfo
+
+A named tuple of a channel's state.
+"""
     __match_args__: Final = (
         "open",
         "closing",
@@ -40,47 +59,160 @@ class ChannelInfo(structseq[int], tuple[bool, bool, bool, int, int, int, int, in
         "num_interp_recv_released",
     )
     @property
-    def open(self) -> bool: ...
+    def open(self) -> bool:
+        """both ends are open
+"""
     @property
-    def closing(self) -> bool: ...
+    def closing(self) -> bool:
+        """send is closed, recv is non-empty
+"""
     @property
-    def closed(self) -> bool: ...
+    def closed(self) -> bool:
+        """both ends are closed
+"""
     @property
-    def count(self) -> int: ...  # type: ignore[override]
+    def count(self) -> int:  # type: ignore[override]
+        """queued objects
+"""
     @property
-    def num_interp_send(self) -> int: ...
+    def num_interp_send(self) -> int:
+        """interpreters bound to the send end
+"""
     @property
-    def num_interp_send_released(self) -> int: ...
+    def num_interp_send_released(self) -> int:
+        """interpreters bound to the send end and released
+"""
     @property
-    def num_interp_recv(self) -> int: ...
+    def num_interp_recv(self) -> int:
+        """interpreters bound to the send end
+"""
     @property
-    def num_interp_recv_released(self) -> int: ...
+    def num_interp_recv_released(self) -> int:
+        """interpreters bound to the send end and released
+"""
     @property
-    def num_interp_both(self) -> int: ...
+    def num_interp_both(self) -> int:
+        """interpreters bound to both ends
+"""
     @property
-    def num_interp_both_recv_released(self) -> int: ...
+    def num_interp_both_recv_released(self) -> int:
+        """interpreters bound to both ends and released_from_the recv end
+"""
     @property
-    def num_interp_both_send_released(self) -> int: ...
+    def num_interp_both_send_released(self) -> int:
+        """interpreters bound to both ends and released_from_the send end
+"""
     @property
-    def num_interp_both_released(self) -> int: ...
+    def num_interp_both_released(self) -> int:
+        """interpreters bound to both ends and released_from_both
+"""
     @property
-    def recv_associated(self) -> bool: ...
+    def recv_associated(self) -> bool:
+        """current interpreter is bound to the recv end
+"""
     @property
-    def recv_released(self) -> bool: ...
+    def recv_released(self) -> bool:
+        """current interpreter *was* bound to the recv end
+"""
     @property
-    def send_associated(self) -> bool: ...
+    def send_associated(self) -> bool:
+        """current interpreter is bound to the send end
+"""
     @property
-    def send_released(self) -> bool: ...
+    def send_released(self) -> bool:
+        """current interpreter *was* bound to the send end
+"""
 
-def create(unboundop: Literal[1, 2, 3]) -> ChannelID: ...
+def create(unboundop: Literal[1, 2, 3]) -> ChannelID:
-def destroy(cid: SupportsIndex) -> None: ...
+    """channel_create(unboundop) -> cid
-def list_all() -> list[ChannelID]: ...
+
-def list_interpreters(cid: SupportsIndex, *, send: bool) -> list[int]: ...
+Create a new cross-interpreter channel and return a unique generated ID.
-def send(cid: SupportsIndex, obj: object, *, blocking: bool = True, timeout: float | None = None) -> None: ...
+"""
-def send_buffer(cid: SupportsIndex, obj: Buffer, *, blocking: bool = True, timeout: float | None = None) -> None: ...
+def destroy(cid: SupportsIndex) -> None:
-def recv(cid: SupportsIndex, default: object = ...) -> tuple[Any, Literal[1, 2, 3]]: ...
+    """channel_destroy(cid)
-def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None: ...
+
-def get_count(cid: SupportsIndex) -> int: ...
+Close and finalize the channel.  Afterward attempts to use the channel
-def get_info(cid: SupportsIndex) -> ChannelInfo: ...
+will behave as though it never existed.
-def get_channel_defaults(cid: SupportsIndex) -> Literal[1, 2, 3]: ...
+"""
-def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None: ...
+def list_all() -> list[ChannelID]:
+    """channel_list_all() -> [cid]
+
+Return the list of all IDs for active channels.
+"""
+def list_interpreters(cid: SupportsIndex, *, send: bool) -> list[int]:
+    """channel_list_interpreters(cid, *, send) -> [id]
+
+Return the list of all interpreter IDs associated with an end of the channel.
+
+The 'send' argument should be a boolean indicating whether to use the send or
+receive end.
+"""
+def send(cid: SupportsIndex, obj: object, *, blocking: bool = True, timeout: float | None = None) -> None:
+    """channel_send(cid, obj, *, blocking=True, timeout=None)
+
+Add the object's data to the channel's queue.
+By default this waits for the object to be received.
+"""
+def send_buffer(cid: SupportsIndex, obj: Buffer, *, blocking: bool = True, timeout: float | None = None) -> None:
+    """channel_send_buffer(cid, obj, *, blocking=True, timeout=None)
+
+Add the object's buffer to the channel's queue.
+By default this waits for the object to be received.
+"""
+def recv(cid: SupportsIndex, default: object = ...) -> tuple[Any, Literal[1, 2, 3]]:
+    """channel_recv(cid, [default]) -> (obj, unboundop)
+
+Return a new object from the data at the front of the channel's queue.
+
+If there is nothing to receive then raise ChannelEmptyError, unless
+a default value is provided.  In that case return it.
+"""
+def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None:
+    """channel_close(cid, *, send=None, recv=None, force=False)
+
+Close the channel for all interpreters.
+
+If the channel is empty then the keyword args are ignored and both
+ends are immediately closed.  Otherwise, if 'force' is True then
+all queued items are released and both ends are immediately
+closed.
+
+If the channel is not empty *and* 'force' is False then following
+happens:
+
+ * recv is True (regardless of send):
+   - raise ChannelNotEmptyError
+ * recv is None and send is None:
+   - raise ChannelNotEmptyError
+ * send is True and recv is not True:
+   - fully close the 'send' end
+   - close the 'recv' end to interpreters not already receiving
+   - fully close it once empty
+
+Closing an already closed channel results in a ChannelClosedError.
+
+Once the channel's ID has no more ref counts in any interpreter
+the channel will be destroyed.
+"""
+def get_count(cid: SupportsIndex) -> int:
+    """get_count(cid)
+
+Return the number of items in the channel.
+"""
+def get_info(cid: SupportsIndex) -> ChannelInfo:
+    """get_info(cid)
+
+Return details about the channel.
+"""
+def get_channel_defaults(cid: SupportsIndex) -> Literal[1, 2, 3]:
+    """get_channel_defaults(cid)
+
+Return the channel's default values, set when it was created.
+"""
+def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None:
+    """channel_release(cid, *, send=None, recv=None, force=True)
+
+Close the channel for the current interpreter.  'send' and 'recv'
+(bool) may be used to indicate the ends to close.  By default both
+ends are closed.  Closing an already closed end is a noop.
+"""

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

@@ -1,19 +1,79 @@
+"""This module provides primitive operations to manage Python interpreters.
+The 'interpreters' module provides a more convenient interface.
+"""
 from typing import Any, Literal, SupportsIndex
 from typing_extensions import TypeAlias
 
 _UnboundOp: TypeAlias = Literal[1, 2, 3]
 
-class QueueError(RuntimeError): ...
+class QueueError(RuntimeError):
+    """Indicates that a queue-related error happened.
+"""
 class QueueNotFoundError(QueueError): ...
 
-def bind(qid: SupportsIndex) -> None: ...
+def bind(qid: SupportsIndex) -> None:
-def create(maxsize: SupportsIndex, fmt: SupportsIndex, unboundop: _UnboundOp) -> int: ...
+    """bind(qid)
-def destroy(qid: SupportsIndex) -> None: ...
+
-def get(qid: SupportsIndex) -> tuple[Any, int, _UnboundOp | None]: ...
+Take a reference to the identified queue.
-def get_count(qid: SupportsIndex) -> int: ...
+The queue is not destroyed until there are no references left.
-def get_maxsize(qid: SupportsIndex) -> int: ...
+"""
-def get_queue_defaults(qid: SupportsIndex) -> tuple[int, _UnboundOp]: ...
+def create(maxsize: SupportsIndex, fmt: SupportsIndex, unboundop: _UnboundOp) -> int:
-def is_full(qid: SupportsIndex) -> bool: ...
+    """create(maxsize, unboundop, fallback) -> qid
-def list_all() -> list[tuple[int, int, _UnboundOp]]: ...
+
-def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex, unboundop: _UnboundOp) -> None: ...
+Create a new cross-interpreter queue and return its unique generated ID.
-def release(qid: SupportsIndex) -> None: ...
+It is a new reference as though bind() had been called on the queue.
+
+The caller is responsible for calling destroy() for the new queue
+before the runtime is finalized.
+"""
+def destroy(qid: SupportsIndex) -> None:
+    """destroy(qid)
+
+Clear and destroy the queue.  Afterward attempts to use the queue
+will behave as though it never existed.
+"""
+def get(qid: SupportsIndex) -> tuple[Any, int, _UnboundOp | None]:
+    """get(qid) -> (obj, unboundop)
+
+Return a new object from the data at the front of the queue.
+The unbound op is also returned.
+
+If there is nothing to receive then raise QueueEmpty.
+"""
+def get_count(qid: SupportsIndex) -> int:
+    """get_count(qid)
+
+Return the number of items in the queue.
+"""
+def get_maxsize(qid: SupportsIndex) -> int:
+    """get_maxsize(qid)
+
+Return the maximum number of items in the queue.
+"""
+def get_queue_defaults(qid: SupportsIndex) -> tuple[int, _UnboundOp]:
+    """get_queue_defaults(qid)
+
+Return the queue's default values, set when it was created.
+"""
+def is_full(qid: SupportsIndex) -> bool:
+    """is_full(qid)
+
+Return true if the queue has a maxsize and has reached it.
+"""
+def list_all() -> list[tuple[int, int, _UnboundOp]]:
+    """list_all() -> [(qid, unboundop, fallback)]
+
+Return the list of IDs for all queues.
+Each corresponding default unbound op and fallback is also included.
+"""
+def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex, unboundop: _UnboundOp) -> None:
+    """put(qid, obj)
+
+Add the object's data to the queue.
+"""
+def release(qid: SupportsIndex) -> None:
+    """release(qid)
+
+Release a reference to the queue.
+The queue is destroyed once there are no references left.
+"""

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

@@ -1,3 +1,6 @@
+"""This module provides primitive operations to manage Python interpreters.
+The 'interpreters' module provides a more convenient interface.
+"""
 import types
 from collections.abc import Callable
 from typing import Any, Final, Literal, SupportsIndex, TypeVar, overload
@@ -8,26 +11,102 @@ _R = TypeVar("_R")
 _Configs: TypeAlias = Literal["default", "isolated", "legacy", "empty", ""]
 _SharedDict: TypeAlias = dict[str, Any]  # many objects can be shared
 
-class InterpreterError(Exception): ...
+class InterpreterError(Exception):
-class InterpreterNotFoundError(InterpreterError): ...
+    """A cross-interpreter operation failed
+"""
+class InterpreterNotFoundError(InterpreterError):
+    """An interpreter was not found
+"""
 class NotShareableError(ValueError): ...
 
 @disjoint_base
 class CrossInterpreterBufferView:
-    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __buffer__(self, flags: int, /) -> memoryview:
+        """Return a buffer object that exposes the underlying memory of the object.
+"""
 
-def new_config(name: _Configs = "isolated", /, **overides: object) -> types.SimpleNamespace: ...
+def new_config(name: _Configs = "isolated", /, **overides: object) -> types.SimpleNamespace:
-def create(config: types.SimpleNamespace | _Configs | None = "isolated", *, reqrefs: bool = False) -> int: ...
+    """new_config(name='isolated', /, **overrides) -> type.SimpleNamespace
-def destroy(id: SupportsIndex, *, restrict: bool = False) -> None: ...
+
-def list_all(*, require_ready: bool = False) -> list[tuple[int, _Whence]]: ...
+Return a representation of a new PyInterpreterConfig.
-def get_current() -> tuple[int, _Whence]: ...
+
-def get_main() -> tuple[int, _Whence]: ...
+The name determines the initial values of the config.  Supported named
-def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool: ...
+configs are: default, isolated, legacy, and empty.
-def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace: ...
+
-def whence(id: SupportsIndex) -> _Whence: ...
+Any keyword arguments are set on the corresponding config fields,
+overriding the initial values.
+"""
+def create(config: types.SimpleNamespace | _Configs | None = "isolated", *, reqrefs: bool = False) -> int:
+    """create([config], *, reqrefs=False) -> ID
+
+Create a new interpreter and return a unique generated ID.
+
+The caller is responsible for destroying the interpreter before exiting,
+typically by using _interpreters.destroy().  This can be managed 
+automatically by passing "reqrefs=True" and then using _incref() and
+_decref() appropriately.
+
+"config" must be a valid interpreter config or the name of a
+predefined config ("isolated" or "legacy").  The default
+is "isolated".
+"""
+def destroy(id: SupportsIndex, *, restrict: bool = False) -> None:
+    """destroy(id, *, restrict=False)
+
+Destroy the identified interpreter.
+
+Attempting to destroy the current interpreter raises InterpreterError.
+So does an unrecognized ID.
+"""
+def list_all(*, require_ready: bool = False) -> list[tuple[int, _Whence]]:
+    """list_all() -> [(ID, whence)]
+
+Return a list containing the ID of every existing interpreter.
+"""
+def get_current() -> tuple[int, _Whence]:
+    """get_current() -> (ID, whence)
+
+Return the ID of current interpreter.
+"""
+def get_main() -> tuple[int, _Whence]:
+    """get_main() -> (ID, whence)
+
+Return the ID of main interpreter.
+"""
+def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool:
+    """is_running(id, *, restrict=False) -> bool
+
+Return whether or not the identified interpreter is running.
+"""
+def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace:
+    """get_config(id, *, restrict=False) -> types.SimpleNamespace
+
+Return a representation of the config used to initialize the interpreter.
+"""
+def whence(id: SupportsIndex) -> _Whence:
+    """whence(id) -> int
+
+Return an identifier for where the interpreter was created.
+"""
 def exec(
     id: SupportsIndex, code: str | types.CodeType | Callable[[], object], shared: _SharedDict = {}, *, restrict: bool = False
-) -> None | types.SimpleNamespace: ...
+) -> None | types.SimpleNamespace:
+    """exec(id, code, shared=None, *, restrict=False)
+
+Execute the provided code in the identified interpreter.
+This is equivalent to running the builtin exec() under the target
+interpreter, using the __dict__ of its __main__ module as both
+globals and locals.
+
+"code" may be a string containing the text of a Python script.
+
+Functions (and code objects) are also supported, with some restrictions.
+The code/function must not take any arguments or be a closure
+(i.e. have cell vars).  Methods and other callables are not supported.
+
+If a function is provided, its code object is used and all its state
+is ignored, including its __globals__ dict.
+"""
 def call(
     id: SupportsIndex,
     callable: Callable[..., _R],
@@ -36,19 +115,54 @@ def call(
     *,
     preserve_exc: bool = False,
     restrict: bool = False,
-) -> tuple[_R, types.SimpleNamespace]: ...
+) -> tuple[_R, types.SimpleNamespace]:
+    """call(id, callable, args=None, kwargs=None, *, restrict=False)
+
+Call the provided object in the identified interpreter.
+Pass the given args and kwargs, if possible.
+"""
 def run_string(
     id: SupportsIndex, script: str | types.CodeType | Callable[[], object], shared: _SharedDict = {}, *, restrict: bool = False
-) -> None: ...
+) -> None:
+    """run_string(id, script, shared=None, *, restrict=False)
+
+Execute the provided string in the identified interpreter.
+
+(See _interpreters.exec().
+"""
 def run_func(
     id: SupportsIndex, func: types.CodeType | Callable[[], object], shared: _SharedDict = {}, *, restrict: bool = False
-) -> None: ...
+) -> None:
-def set___main___attrs(id: SupportsIndex, updates: _SharedDict, *, restrict: bool = False) -> None: ...
+    """run_func(id, func, shared=None, *, restrict=False)
+
+Execute the body of the provided function in the identified interpreter.
+Code objects are also supported.  In both cases, closures and args
+are not supported.  Methods and other callables are not supported either.
+
+(See _interpreters.exec().
+"""
+def set___main___attrs(id: SupportsIndex, updates: _SharedDict, *, restrict: bool = False) -> None:
+    """set___main___attrs(id, ns, *, restrict=False)
+
+Bind the given attributes in the interpreter's __main__ module.
+"""
 def incref(id: SupportsIndex, *, implieslink: bool = False, restrict: bool = False) -> None: ...
 def decref(id: SupportsIndex, *, restrict: bool = False) -> None: ...
-def is_shareable(obj: object) -> bool: ...
+def is_shareable(obj: object) -> bool:
+    """is_shareable(obj) -> bool
+
+Return True if the object's data may be shared between interpreters and
+False otherwise.
+"""
 @overload
-def capture_exception(exc: BaseException) -> types.SimpleNamespace: ...
+def capture_exception(exc: BaseException) -> types.SimpleNamespace:
+    """capture_exception(exc=None) -> types.SimpleNamespace
+
+Return a snapshot of an exception.  If "exc" is None
+then the current exception, if any, is used (but not cleared).
+
+The returned snapshot is the same as what _interpreters.exec() returns.
+"""
 @overload
 def capture_exception(exc: None = None) -> types.SimpleNamespace | None: ...
 

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

@@ -1,3 +1,36 @@
+"""The io module provides the Python interfaces to stream handling. The
+builtin open function is defined in this module.
+
+At the top of the I/O hierarchy is the abstract base class IOBase. It
+defines the basic interface to a stream. Note, however, that there is no
+separation between reading and writing to streams; implementations are
+allowed to raise an OSError if they do not support a given operation.
+
+Extending IOBase is RawIOBase which deals simply with the reading and
+writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide
+an interface to OS files.
+
+BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its
+subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer
+streams that are readable, writable, and both respectively.
+BufferedRandom provides a buffered interface to random access
+streams. BytesIO is a simple stream of in-memory bytes.
+
+Another IOBase subclass, TextIOBase, deals with the encoding and decoding
+of streams into text. TextIOWrapper, which extends it, is a buffered text
+interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO
+is an in-memory stream for text.
+
+Argument names are not part of the specification, and only the arguments
+of open() are intended to be used as keyword arguments.
+
+data:
+
+DEFAULT_BUFFER_SIZE
+
+   An int containing the default buffer size used by the module's buffered
+   I/O classes.
+"""
 import builtins
 import codecs
 import sys
@@ -18,69 +51,290 @@ else:
 
 open = builtins.open
 
-def open_code(path: str) -> IO[bytes]: ...
+def open_code(path: str) -> IO[bytes]:
+    """Opens the provided file with the intent to import the contents.
+
+This may perform extra validation beyond open(), but is otherwise interchangeable
+with calling open(path, 'rb').
+"""
 
 BlockingIOError = builtins.BlockingIOError
 
 if sys.version_info >= (3, 12):
     @disjoint_base
     class _IOBase:
-        def __iter__(self) -> Iterator[bytes]: ...
+        """The abstract base class for all I/O classes.
-        def __next__(self) -> bytes: ...
+
+This class provides dummy implementations for many methods that
+derived classes can override selectively; the default implementations
+represent a file that cannot be read, written or seeked.
+
+Even though IOBase does not declare read, readinto, or write because
+their signatures will vary, implementations and clients should
+consider those methods part of the interface. Also, implementations
+may raise UnsupportedOperation when operations they do not support are
+called.
+
+The basic type used for binary data read from or written to a file is
+bytes. Other bytes-like objects are accepted as method arguments too.
+In some cases (such as readinto), a writable object is required. Text
+I/O classes work with str data.
+
+Note that calling any method (except additional calls to close(),
+which are ignored) on a closed stream should raise a ValueError.
+
+IOBase (and its subclasses) support the iterator protocol, meaning
+that an IOBase object can be iterated over yielding the lines in a
+stream.
+
+IOBase also supports the :keyword:`with` statement. In this example,
+fp is closed after the suite of the with statement is complete:
+
+with open('spam.txt', 'r') as fp:
+    fp.write('Spam and eggs!')
+"""
+        def __iter__(self) -> Iterator[bytes]:
+            """Implement iter(self).
+"""
+        def __next__(self) -> bytes:
+            """Implement next(self).
+"""
         def __enter__(self) -> Self: ...
         def __exit__(
             self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
         ) -> None: ...
-        def close(self) -> None: ...
+        def close(self) -> None:
-        def fileno(self) -> int: ...
+            """Flush and close the IO object.
-        def flush(self) -> None: ...
+
-        def isatty(self) -> bool: ...
+This method has no effect if the file is already closed.
-        def readable(self) -> bool: ...
+"""
+        def fileno(self) -> int:
+            """Return underlying file descriptor if one exists.
+
+Raise OSError if the IO object does not use a file descriptor.
+"""
+        def flush(self) -> None:
+            """Flush write buffers, if applicable.
+
+This is not implemented for read-only and non-blocking streams.
+"""
+        def isatty(self) -> bool:
+            """Return whether this is an 'interactive' stream.
+
+Return False if it can't be determined.
+"""
+        def readable(self) -> bool:
+            """Return whether object was opened for reading.
+
+If False, read() will raise OSError.
+"""
         read: Callable[..., Any]
-        def readlines(self, hint: int = -1, /) -> list[bytes]: ...
+        def readlines(self, hint: int = -1, /) -> list[bytes]:
-        def seek(self, offset: int, whence: int = 0, /) -> int: ...
+            """Return a list of lines from the stream.
-        def seekable(self) -> bool: ...
+
-        def tell(self) -> int: ...
+hint can be specified to control the number of lines read: no more
-        def truncate(self, size: int | None = None, /) -> int: ...
+lines will be read if the total size (in bytes/characters) of all
-        def writable(self) -> bool: ...
+lines so far exceeds hint.
+"""
+        def seek(self, offset: int, whence: int = 0, /) -> int:
+            """Change the stream position to the given byte offset.
+
+  offset
+    The stream position, relative to 'whence'.
+  whence
+    The relative position to seek from.
+
+The offset is interpreted relative to the position indicated by whence.
+Values for whence are:
+
+* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive
+* os.SEEK_CUR or 1 -- current stream position; offset may be negative
+* os.SEEK_END or 2 -- end of stream; offset is usually negative
+
+Return the new absolute position.
+"""
+        def seekable(self) -> bool:
+            """Return whether object supports random access.
+
+If False, seek(), tell() and truncate() will raise OSError.
+This method may need to do a test seek().
+"""
+        def tell(self) -> int:
+            """Return current stream position.
+"""
+        def truncate(self, size: int | None = None, /) -> int:
+            """Truncate file to size bytes.
+
+File pointer is left unchanged. Size defaults to the current IO position
+as reported by tell(). Return the new size.
+"""
+        def writable(self) -> bool:
+            """Return whether object was opened for writing.
+
+If False, write() will raise OSError.
+"""
         write: Callable[..., Any]
-        def writelines(self, lines: Iterable[ReadableBuffer], /) -> None: ...
+        def writelines(self, lines: Iterable[ReadableBuffer], /) -> None:
-        def readline(self, size: int | None = -1, /) -> bytes: ...
+            """Write a list of lines to stream.
-        def __del__(self) -> None: ...
+
+Line separators are not added, so it is usual for each of the
+lines provided to have a line separator at the end.
+"""
+        def readline(self, size: int | None = -1, /) -> bytes:
+            """Read and return a line from the stream.
+
+If size is specified, at most size bytes will be read.
+
+The line terminator is always b'\\n' for binary files; for text
+files, the newlines argument to open can be used to select the line
+terminator(s) recognized.
+"""
+        def __del__(self) -> None:
+            """Called when the instance is about to be destroyed.
+"""
         @property
         def closed(self) -> bool: ...
         def _checkClosed(self) -> None: ...  # undocumented
 
 else:
     class _IOBase:
-        def __iter__(self) -> Iterator[bytes]: ...
+        """The abstract base class for all I/O classes.
-        def __next__(self) -> bytes: ...
+
+This class provides dummy implementations for many methods that
+derived classes can override selectively; the default implementations
+represent a file that cannot be read, written or seeked.
+
+Even though IOBase does not declare read, readinto, or write because
+their signatures will vary, implementations and clients should
+consider those methods part of the interface. Also, implementations
+may raise UnsupportedOperation when operations they do not support are
+called.
+
+The basic type used for binary data read from or written to a file is
+bytes. Other bytes-like objects are accepted as method arguments too.
+In some cases (such as readinto), a writable object is required. Text
+I/O classes work with str data.
+
+Note that calling any method (except additional calls to close(),
+which are ignored) on a closed stream should raise a ValueError.
+
+IOBase (and its subclasses) support the iterator protocol, meaning
+that an IOBase object can be iterated over yielding the lines in a
+stream.
+
+IOBase also supports the :keyword:`with` statement. In this example,
+fp is closed after the suite of the with statement is complete:
+
+with open('spam.txt', 'r') as fp:
+    fp.write('Spam and eggs!')
+"""
+        def __iter__(self) -> Iterator[bytes]:
+            """Implement iter(self).
+"""
+        def __next__(self) -> bytes:
+            """Implement next(self).
+"""
         def __enter__(self) -> Self: ...
         def __exit__(
             self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
         ) -> None: ...
-        def close(self) -> None: ...
+        def close(self) -> None:
-        def fileno(self) -> int: ...
+            """Flush and close the IO object.
-        def flush(self) -> None: ...
+
-        def isatty(self) -> bool: ...
+This method has no effect if the file is already closed.
-        def readable(self) -> bool: ...
+"""
+        def fileno(self) -> int:
+            """Returns underlying file descriptor if one exists.
+
+OSError is raised if the IO object does not use a file descriptor.
+"""
+        def flush(self) -> None:
+            """Flush write buffers, if applicable.
+
+This is not implemented for read-only and non-blocking streams.
+"""
+        def isatty(self) -> bool:
+            """Return whether this is an 'interactive' stream.
+
+Return False if it can't be determined.
+"""
+        def readable(self) -> bool:
+            """Return whether object was opened for reading.
+
+If False, read() will raise OSError.
+"""
         read: Callable[..., Any]
-        def readlines(self, hint: int = -1, /) -> list[bytes]: ...
+        def readlines(self, hint: int = -1, /) -> list[bytes]:
-        def seek(self, offset: int, whence: int = 0, /) -> int: ...
+            """Return a list of lines from the stream.
-        def seekable(self) -> bool: ...
+
-        def tell(self) -> int: ...
+hint can be specified to control the number of lines read: no more
-        def truncate(self, size: int | None = None, /) -> int: ...
+lines will be read if the total size (in bytes/characters) of all
-        def writable(self) -> bool: ...
+lines so far exceeds hint.
+"""
+        def seek(self, offset: int, whence: int = 0, /) -> int:
+            """Change the stream position to the given byte offset.
+
+  offset
+    The stream position, relative to 'whence'.
+  whence
+    The relative position to seek from.
+
+The offset is interpreted relative to the position indicated by whence.
+Values for whence are:
+
+* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive
+* os.SEEK_CUR or 1 -- current stream position; offset may be negative
+* os.SEEK_END or 2 -- end of stream; offset is usually negative
+
+Return the new absolute position.
+"""
+        def seekable(self) -> bool:
+            """Return whether object supports random access.
+
+If False, seek(), tell() and truncate() will raise OSError.
+This method may need to do a test seek().
+"""
+        def tell(self) -> int:
+            """Return current stream position.
+"""
+        def truncate(self, size: int | None = None, /) -> int:
+            """Truncate file to size bytes.
+
+File pointer is left unchanged.  Size defaults to the current IO
+position as reported by tell().  Returns the new size.
+"""
+        def writable(self) -> bool:
+            """Return whether object was opened for writing.
+
+If False, write() will raise OSError.
+"""
         write: Callable[..., Any]
-        def writelines(self, lines: Iterable[ReadableBuffer], /) -> None: ...
+        def writelines(self, lines: Iterable[ReadableBuffer], /) -> None:
-        def readline(self, size: int | None = -1, /) -> bytes: ...
+            """Write a list of lines to stream.
+
+Line separators are not added, so it is usual for each of the
+lines provided to have a line separator at the end.
+"""
+        def readline(self, size: int | None = -1, /) -> bytes:
+            """Read and return a line from the stream.
+
+If size is specified, at most size bytes will be read.
+
+The line terminator is always b'\\n' for binary files; for text
+files, the newlines argument to open can be used to select the line
+terminator(s) recognized.
+"""
         def __del__(self) -> None: ...
         @property
         def closed(self) -> bool: ...
         def _checkClosed(self) -> None: ...  # undocumented
 
 class _RawIOBase(_IOBase):
-    def readall(self) -> bytes: ...
+    """Base class for raw binary I/O.
+"""
+    def readall(self) -> bytes:
+        """Read until EOF, using multiple read() call.
+"""
     # The following methods can return None if the file is in non-blocking mode
     # and no data is available.
     def readinto(self, buffer: WriteableBuffer, /) -> int | MaybeNone: ...
@@ -88,15 +342,78 @@ class _RawIOBase(_IOBase):
     def read(self, size: int = -1, /) -> bytes | MaybeNone: ...
 
 class _BufferedIOBase(_IOBase):
-    def detach(self) -> RawIOBase: ...
+    """Base class for buffered IO objects.
+
+The main difference with RawIOBase is that the read() method
+supports omitting the size argument, and does not have a default
+implementation that defers to readinto().
+
+In addition, read(), readinto() and write() may raise
+BlockingIOError if the underlying raw stream is in non-blocking
+mode and not ready; unlike their raw counterparts, they will never
+return None.
+
+A typical implementation should not inherit from a RawIOBase
+implementation, but wrap one.
+"""
+    def detach(self) -> RawIOBase:
+        """Disconnect this buffer from its underlying raw stream and return it.
+
+After the raw stream has been detached, the buffer is in an unusable
+state.
+"""
     def readinto(self, buffer: WriteableBuffer, /) -> int: ...
-    def write(self, buffer: ReadableBuffer, /) -> int: ...
+    def write(self, buffer: ReadableBuffer, /) -> int:
+        """Write buffer b to the IO stream.
+
+Return the number of bytes written, which is always
+the length of b in bytes.
+
+Raise BlockingIOError if the buffer is full and the
+underlying raw stream cannot accept more data at the moment.
+"""
     def readinto1(self, buffer: WriteableBuffer, /) -> int: ...
-    def read(self, size: int | None = -1, /) -> bytes: ...
+    def read(self, size: int | None = -1, /) -> bytes:
-    def read1(self, size: int = -1, /) -> bytes: ...
+        """Read and return up to n bytes.
+
+If the size argument is omitted, None, or negative, read and
+return all data until EOF.
+
+If the size argument is positive, and the underlying raw stream is
+not 'interactive', multiple raw reads may be issued to satisfy
+the byte count (unless EOF is reached first).
+However, for interactive raw streams (as well as sockets and pipes),
+at most one raw read will be issued, and a short result does not
+imply that EOF is imminent.
+
+Return an empty bytes object on EOF.
+
+Return None if the underlying raw stream was open in non-blocking
+mode and no data is available at the moment.
+"""
+    def read1(self, size: int = -1, /) -> bytes:
+        """Read and return up to size bytes, with at most one read() call to the underlying raw stream.
+
+Return an empty bytes object on EOF.
+A short result does not imply that EOF is imminent.
+"""
 
 @disjoint_base
 class FileIO(RawIOBase, _RawIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+    """Open a file.
+
+The mode can be 'r' (default), 'w', 'x' or 'a' for reading,
+writing, exclusive creation or appending.  The file will be created if it
+doesn't exist when opened for writing or appending; it will be truncated
+when opened for writing.  A FileExistsError will be raised if it already
+exists when opened for creating. Opening a file for creating implies
+writing so this mode behaves in a similar way to 'w'.Add a '+' to the mode
+to allow simultaneous reading and writing. A custom opener can be used by
+passing a callable as *opener*. The underlying file descriptor for the file
+object is then obtained by calling opener with (*name*, *flags*).
+*opener* must return an open file descriptor (passing os.open as *opener*
+results in functionality similar to passing None).
+"""
     mode: str
     # The type of "name" equals the argument passed in to the constructor,
     # but that can make FileIO incompatible with other I/O types that assume
@@ -106,22 +423,70 @@ class FileIO(RawIOBase, _RawIOBase, BinaryIO):  # type: ignore[misc]  # incompat
         self, file: FileDescriptorOrPath, mode: str = "r", closefd: bool = True, opener: _Opener | None = None
     ) -> None: ...
     @property
-    def closefd(self) -> bool: ...
+    def closefd(self) -> bool:
-    def seek(self, pos: int, whence: int = 0, /) -> int: ...
+        """True if the file descriptor will be closed by close().
-    def read(self, size: int | None = -1, /) -> bytes | MaybeNone: ...
+"""
+    def seek(self, pos: int, whence: int = 0, /) -> int:
+        """Move to new file position and return the file position.
+
+Argument offset is a byte count.  Optional argument whence defaults to
+SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values
+are SEEK_CUR or 1 (move relative to current position, positive or negative),
+and SEEK_END or 2 (move relative to end of file, usually negative, although
+many platforms allow seeking beyond the end of a file).
+
+Note that not all file objects are seekable.
+"""
+    def read(self, size: int | None = -1, /) -> bytes | MaybeNone:
+        """Read at most size bytes, returned as bytes.
+
+If size is less than 0, read all bytes in the file making multiple read calls.
+See ``FileIO.readall``.
+
+Attempts to make only one system call, retrying only per PEP 475 (EINTR). This
+means less data may be returned than requested.
+
+In non-blocking mode, returns None if no data is available. Return an empty
+bytes object at EOF.
+"""
 
 @disjoint_base
 class BytesIO(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+    """Buffered I/O implementation using an in-memory bytes buffer.
+"""
     def __init__(self, initial_bytes: ReadableBuffer = b"") -> None: ...
     # BytesIO does not contain a "name" field. This workaround is necessary
     # to allow BytesIO sub-classes to add this field, as it is defined
     # as a read-only property on IO[].
     name: Any
-    def getvalue(self) -> bytes: ...
+    def getvalue(self) -> bytes:
-    def getbuffer(self) -> memoryview: ...
+        """Retrieve the entire contents of the BytesIO object.
-    def read1(self, size: int | None = -1, /) -> bytes: ...
+"""
-    def readlines(self, size: int | None = None, /) -> list[bytes]: ...
+    def getbuffer(self) -> memoryview:
-    def seek(self, pos: int, whence: int = 0, /) -> int: ...
+        """Get a read-write view over the contents of the BytesIO object.
+"""
+    def read1(self, size: int | None = -1, /) -> bytes:
+        """Read at most size bytes, returned as a bytes object.
+
+If the size argument is negative or omitted, read until EOF is reached.
+Return an empty bytes object at EOF.
+"""
+    def readlines(self, size: int | None = None, /) -> list[bytes]:
+        """List of bytes objects, each a line from the file.
+
+Call readline() repeatedly and return a list of the lines so read.
+The optional size argument, if given, is an approximate bound on the
+total number of bytes in the lines returned.
+"""
+    def seek(self, pos: int, whence: int = 0, /) -> int:
+        """Change stream position.
+
+Seek to byte offset pos relative to position indicated by whence:
+     0  Start of stream (the default).  pos should be >= 0;
+     1  Current position - pos may be negative;
+     2  End of stream - pos usually negative.
+Returns the new absolute position.
+"""
 
 @type_check_only
 class _BufferedReaderStream(Protocol):
@@ -153,6 +518,8 @@ _BufferedReaderStreamT = TypeVar("_BufferedReaderStreamT", bound=_BufferedReader
 
 @disjoint_base
 class BufferedReader(BufferedIOBase, _BufferedIOBase, BinaryIO, Generic[_BufferedReaderStreamT]):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+    """Create a new buffered reader using the given readable raw IO object.
+"""
     raw: _BufferedReaderStreamT
     if sys.version_info >= (3, 14):
         def __init__(self, raw: _BufferedReaderStreamT, buffer_size: int = 131072) -> None: ...
@@ -165,6 +532,12 @@ class BufferedReader(BufferedIOBase, _BufferedIOBase, BinaryIO, Generic[_Buffere
 
 @disjoint_base
 class BufferedWriter(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+    """A buffer for a writeable sequential RawIO object.
+
+The constructor creates a BufferedWriter for the given writeable raw
+stream. If the buffer_size is not given, it defaults to
+DEFAULT_BUFFER_SIZE.
+"""
     raw: RawIOBase
     if sys.version_info >= (3, 14):
         def __init__(self, raw: RawIOBase, buffer_size: int = 131072) -> None: ...
@@ -177,6 +550,12 @@ class BufferedWriter(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore
 
 @disjoint_base
 class BufferedRandom(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+    """A buffered interface to random access streams.
+
+The constructor creates a reader and writer for a seekable stream,
+raw, given in the first argument. If the buffer_size is omitted it
+defaults to DEFAULT_BUFFER_SIZE.
+"""
     mode: str
     name: Any
     raw: RawIOBase
@@ -191,6 +570,16 @@ class BufferedRandom(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore
 
 @disjoint_base
 class BufferedRWPair(BufferedIOBase, _BufferedIOBase, Generic[_BufferedReaderStreamT]):
+    """A buffered reader and writer object together.
+
+A buffered reader object and buffered writer object put together to
+form a sequential IO object that can read and write. This is typically
+used with a socket or two-way pipe.
+
+reader and writer are RawIOBase objects that are readable and
+writeable respectively. If the buffer_size is omitted it defaults to
+DEFAULT_BUFFER_SIZE.
+"""
     if sys.version_info >= (3, 14):
         def __init__(self, reader: _BufferedReaderStreamT, writer: RawIOBase, buffer_size: int = 131072, /) -> None: ...
     else:
@@ -199,17 +588,57 @@ class BufferedRWPair(BufferedIOBase, _BufferedIOBase, Generic[_BufferedReaderStr
     def peek(self, size: int = 0, /) -> bytes: ...
 
 class _TextIOBase(_IOBase):
+    """Base class for text I/O.
+
+This class provides a character and line based interface to stream
+I/O. There is no readinto method because Python's character strings
+are immutable.
+"""
     encoding: str
     errors: str | None
     newlines: str | tuple[str, ...] | None
-    def __iter__(self) -> Iterator[str]: ...  # type: ignore[override]
+    def __iter__(self) -> Iterator[str]:  # type: ignore[override]
-    def __next__(self) -> str: ...  # type: ignore[override]
+        """Implement iter(self).
-    def detach(self) -> BinaryIO: ...
+"""
-    def write(self, s: str, /) -> int: ...
+    def __next__(self) -> str:  # type: ignore[override]
-    def writelines(self, lines: Iterable[str], /) -> None: ...  # type: ignore[override]
+        """Implement next(self).
-    def readline(self, size: int = -1, /) -> str: ...  # type: ignore[override]
+"""
-    def readlines(self, hint: int = -1, /) -> list[str]: ...  # type: ignore[override]
+    def detach(self) -> BinaryIO:
-    def read(self, size: int | None = -1, /) -> str: ...
+        """Separate the underlying buffer from the TextIOBase and return it.
+
+After the underlying buffer has been detached, the TextIO is in an unusable state.
+"""
+    def write(self, s: str, /) -> int:
+        """Write string s to stream.
+
+Return the number of characters written
+(which is always equal to the length of the string).
+"""
+    def writelines(self, lines: Iterable[str], /) -> None:  # type: ignore[override]
+        """Write a list of lines to stream.
+
+Line separators are not added, so it is usual for each of the
+lines provided to have a line separator at the end.
+"""
+    def readline(self, size: int = -1, /) -> str:  # type: ignore[override]
+        """Read until newline or EOF.
+
+Return an empty string if EOF is hit immediately.
+If size is specified, at most size characters will be read.
+"""
+    def readlines(self, hint: int = -1, /) -> list[str]:  # type: ignore[override]
+        """Return a list of lines from the stream.
+
+hint can be specified to control the number of lines read: no more
+lines will be read if the total size (in bytes/characters) of all
+lines so far exceeds hint.
+"""
+    def read(self, size: int | None = -1, /) -> str:
+        """Read at most size characters from stream.
+
+Read from underlying buffer until we have size characters or we hit EOF.
+If size is negative or omitted, read until EOF.
+"""
 
 @type_check_only
 class _WrappedBuffer(Protocol):
@@ -238,6 +667,35 @@ _BufferT_co = TypeVar("_BufferT_co", bound=_WrappedBuffer, default=_WrappedBuffe
 
 @disjoint_base
 class TextIOWrapper(TextIOBase, _TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[misc]  # incompatible definitions of write in the base classes
+    """Character and line based layer over a BufferedIOBase object, buffer.
+
+encoding gives the name of the encoding that the stream will be
+decoded or encoded with. It defaults to locale.getencoding().
+
+errors determines the strictness of encoding and decoding (see
+help(codecs.Codec) or the documentation for codecs.register) and
+defaults to "strict".
+
+newline controls how line endings are handled. It can be None, '',
+'\\n', '\\r', and '\\r\\n'.  It works as follows:
+
+* On input, if newline is None, universal newlines mode is
+  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and
+  these are translated into '\\n' before being returned to the
+  caller. If it is '', universal newline mode is enabled, but line
+  endings are returned to the caller untranslated. If it has any of
+  the other legal values, input lines are only terminated by the given
+  string, and the line ending is returned to the caller untranslated.
+
+* On output, if newline is None, any '\\n' characters written are
+  translated to the system default line separator, os.linesep. If
+  newline is '' or '\\n', no translation takes place. If newline is any
+  of the other legal values, any '\\n' characters written are translated
+  to the given string.
+
+If line_buffering is True, a call to flush is implied when a call to
+write contains a newline character.
+"""
     def __init__(
         self,
         buffer: _BufferT_co,
@@ -262,30 +720,83 @@ class TextIOWrapper(TextIOBase, _TextIOBase, TextIO, Generic[_BufferT_co]):  # t
         newline: str | None = None,
         line_buffering: bool | None = None,
         write_through: bool | None = None,
-    ) -> None: ...
+    ) -> None:
+        """Reconfigure the text stream with new parameters.
+
+This also does an implicit stream flush.
+"""
     def readline(self, size: int = -1, /) -> str: ...  # type: ignore[override]
     # Equals the "buffer" argument passed in to the constructor.
     def detach(self) -> _BufferT_co: ...  # type: ignore[override]
     # TextIOWrapper's version of seek only supports a limited subset of
     # operations.
-    def seek(self, cookie: int, whence: int = 0, /) -> int: ...
+    def seek(self, cookie: int, whence: int = 0, /) -> int:
+        """Set the stream position, and return the new stream position.
+
+  cookie
+    Zero or an opaque number returned by tell().
+  whence
+    The relative position to seek from.
+
+Four operations are supported, given by the following argument
+combinations:
+
+- seek(0, SEEK_SET): Rewind to the start of the stream.
+- seek(cookie, SEEK_SET): Restore a previous position;
+  'cookie' must be a number returned by tell().
+- seek(0, SEEK_END): Fast-forward to the end of the stream.
+- seek(0, SEEK_CUR): Leave the current stream position unchanged.
+
+Any other argument combinations are invalid,
+and may raise exceptions.
+"""
     def truncate(self, pos: int | None = None, /) -> int: ...
 
 @disjoint_base
 class StringIO(TextIOBase, _TextIOBase, TextIO):  # type: ignore[misc]  # incompatible definitions of write in the base classes
+    """Text I/O implementation using an in-memory buffer.
+
+The initial_value argument sets the value of object.  The newline
+argument is like the one of TextIOWrapper's constructor.
+"""
     def __init__(self, initial_value: str | None = "", newline: str | None = "\n") -> None: ...
     # StringIO does not contain a "name" field. This workaround is necessary
     # to allow StringIO sub-classes to add this field, as it is defined
     # as a read-only property on IO[].
     name: Any
-    def getvalue(self) -> str: ...
+    def getvalue(self) -> str:
+        """Retrieve the entire contents of the object.
+"""
     @property
     def line_buffering(self) -> bool: ...
-    def seek(self, pos: int, whence: int = 0, /) -> int: ...
+    def seek(self, pos: int, whence: int = 0, /) -> int:
-    def truncate(self, pos: int | None = None, /) -> int: ...
+        """Change stream position.
+
+Seek to character offset pos relative to position indicated by whence:
+    0  Start of stream (the default).  pos should be >= 0;
+    1  Current position - pos must be 0;
+    2  End of stream - pos must be 0.
+Returns the new absolute position.
+"""
+    def truncate(self, pos: int | None = None, /) -> int:
+        """Truncate size to pos.
+
+The pos argument defaults to the current file position, as
+returned by tell().  The current file position is unchanged.
+Returns the new absolute position.
+"""
 
 @disjoint_base
 class IncrementalNewlineDecoder:
+    """Codec used when reading a file in universal newlines mode.
+
+It wraps another incremental decoder, translating \\r\\n and \\r into \\n.
+It also records the types of newlines encountered.  When used with
+translate=False, it ensures that the newline sequence is returned in
+one piece. When used with decoder=None, it expects unicode strings as
+decode input and translates newlines without first invoking an external
+decoder.
+"""
     def __init__(self, decoder: codecs.IncrementalDecoder | None, translate: bool, errors: str = "strict") -> None: ...
     def decode(self, input: ReadableBuffer | str, final: bool = False) -> str: ...
     @property
@@ -296,6 +807,18 @@ class IncrementalNewlineDecoder:
 
 if sys.version_info >= (3, 10):
     @overload
-    def text_encoding(encoding: None, stacklevel: int = 2, /) -> Literal["locale", "utf-8"]: ...
+    def text_encoding(encoding: None, stacklevel: int = 2, /) -> Literal["locale", "utf-8"]:
+        """A helper function to choose the text encoding.
+
+When encoding is not None, this function returns it.
+Otherwise, this function returns the default text encoding
+(i.e. "locale" or "utf-8" depends on UTF-8 mode).
+
+This function emits an EncodingWarning if encoding is None and
+sys.flags.warn_default_encoding is true.
+
+This can be used in APIs with an encoding=None parameter.
+However, please consider using encoding="utf-8" for new APIs.
+"""
     @overload
     def text_encoding(encoding: _T, stacklevel: int = 2, /) -> _T: ...

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

@@ -1,25 +1,45 @@
+"""json speedups
+"""
 from collections.abc import Callable
 from typing import Any, final
 from typing_extensions import Self
 
 @final
 class make_encoder:
+    """Encoder(markers, default, encoder, indent, key_separator, item_separator, sort_keys, skipkeys, allow_nan)
+"""
     @property
-    def sort_keys(self) -> bool: ...
+    def sort_keys(self) -> bool:
+        """sort_keys
+"""
     @property
-    def skipkeys(self) -> bool: ...
+    def skipkeys(self) -> bool:
+        """skipkeys
+"""
     @property
-    def key_separator(self) -> str: ...
+    def key_separator(self) -> str:
+        """key_separator
+"""
     @property
-    def indent(self) -> str | None: ...
+    def indent(self) -> str | None:
+        """indent
+"""
     @property
-    def markers(self) -> dict[int, Any] | None: ...
+    def markers(self) -> dict[int, Any] | None:
+        """markers
+"""
     @property
-    def default(self) -> Callable[[Any], Any]: ...
+    def default(self) -> Callable[[Any], Any]:
+        """default
+"""
     @property
-    def encoder(self) -> Callable[[str], str]: ...
+    def encoder(self) -> Callable[[str], str]:
+        """encoder
+"""
     @property
-    def item_separator(self) -> str: ...
+    def item_separator(self) -> str:
+        """item_separator
+"""
     def __new__(
         cls,
         markers: dict[int, Any] | None,
@@ -32,10 +52,14 @@ class make_encoder:
         skipkeys: bool,
         allow_nan: bool,
     ) -> Self: ...
-    def __call__(self, obj: object, _current_indent_level: int) -> Any: ...
+    def __call__(self, obj: object, _current_indent_level: int) -> Any:
+        """Call self as a function.
+"""
 
 @final
 class make_scanner:
+    """JSON scanner object
+"""
     object_hook: Any
     object_pairs_hook: Any
     parse_int: Any
@@ -44,8 +68,29 @@ class make_scanner:
     strict: bool
     # TODO: 'context' needs the attrs above (ducktype), but not __call__.
     def __new__(cls, context: make_scanner) -> Self: ...
-    def __call__(self, string: str, index: int) -> tuple[Any, int]: ...
+    def __call__(self, string: str, index: int) -> tuple[Any, int]:
+        """Call self as a function.
+"""
 
-def encode_basestring(s: str, /) -> str: ...
+def encode_basestring(s: str, /) -> str:
-def encode_basestring_ascii(s: str, /) -> str: ...
+    """encode_basestring(string) -> string
-def scanstring(string: str, end: int, strict: bool = True) -> tuple[str, int]: ...
+
+Return a JSON representation of a Python string
+"""
+def encode_basestring_ascii(s: str, /) -> str:
+    """encode_basestring_ascii(string) -> string
+
+Return an ASCII-only JSON representation of a Python string
+"""
+def scanstring(string: str, end: int, strict: bool = True) -> tuple[str, int]:
+    """scanstring(string, end, strict=True) -> (string, end)
+
+Scan the string s for a JSON string. End is the index of the
+character in s after the quote that started the JSON string.
+Unescapes all valid JSON string escape sequences and raises ValueError
+on attempt to decode an invalid string. If strict is False then literal
+control characters are allowed in the string.
+
+Returns a tuple of the decoded string and the index of the character in s
+after the end quote.
+"""

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

@@ -1,3 +1,5 @@
+"""Support for POSIX locales.
+"""
 import sys
 from _typeshed import StrPath
 from typing import Final, Literal, TypedDict, type_check_only
@@ -31,14 +33,24 @@ LC_NUMERIC: Final[int]
 LC_ALL: Final[int]
 CHAR_MAX: Final = 127
 
-def setlocale(category: int, locale: str | None = None, /) -> str: ...
+def setlocale(category: int, locale: str | None = None, /) -> str:
-def localeconv() -> _LocaleConv: ...
+    """Activates/queries locale processing.
+"""
+def localeconv() -> _LocaleConv:
+    """Returns numeric and monetary locale-specific parameters.
+"""
 
 if sys.version_info >= (3, 11):
-    def getencoding() -> str: ...
+    def getencoding() -> str:
+        """Get the current locale encoding.
+"""
 
-def strcoll(os1: str, os2: str, /) -> int: ...
+def strcoll(os1: str, os2: str, /) -> int:
-def strxfrm(string: str, /) -> str: ...
+    """Compares two strings according to the locale.
+"""
+def strxfrm(string: str, /) -> str:
+    """Return a string that can be used as a key for locale-aware comparisons.
+"""
 
 # native gettext functions
 # https://docs.python.org/3/library/locale.html#access-to-message-catalogs
@@ -108,14 +120,32 @@ if sys.platform != "win32":
     CRNCYSTR: Final[int]
     ALT_DIGITS: Final[int]
 
-    def nl_langinfo(key: int, /) -> str: ...
+    def nl_langinfo(key: int, /) -> str:
+        """Return the value for the locale information associated with key.
+"""
 
     # This is dependent on `libintl.h` which is a part of `gettext`
     # system dependency. These functions might be missing.
     # But, we always say that they are present.
-    def gettext(msg: str, /) -> str: ...
+    def gettext(msg: str, /) -> str:
-    def dgettext(domain: str | None, msg: str, /) -> str: ...
+        """gettext(msg) -> string
-    def dcgettext(domain: str | None, msg: str, category: int, /) -> str: ...
+
-    def textdomain(domain: str | None, /) -> str: ...
+Return translation of msg.
-    def bindtextdomain(domain: str, dir: StrPath | None, /) -> str: ...
+"""
-    def bind_textdomain_codeset(domain: str, codeset: str | None, /) -> str | None: ...
+    def dgettext(domain: str | None, msg: str, /) -> str:
+        """dgettext(domain, msg) -> string
+
+Return translation of msg in domain.
+"""
+    def dcgettext(domain: str | None, msg: str, category: int, /) -> str:
+        """Return translation of msg in domain and category.
+"""
+    def textdomain(domain: str | None, /) -> str:
+        """Set the C library's textdmain to domain, returning the new domain.
+"""
+    def bindtextdomain(domain: str, dir: StrPath | None, /) -> str:
+        """Bind the C library's domain to dir.
+"""
+    def bind_textdomain_codeset(domain: str, codeset: str | None, /) -> str | None:
+        """Bind the C library's domain to codeset.
+"""

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

@@ -1,3 +1,5 @@
+"""Fast profiler
+"""
 import sys
 from _typeshed import structseq
 from collections.abc import Callable
@@ -7,13 +9,57 @@ from typing_extensions import disjoint_base
 
 @disjoint_base
 class Profiler:
+    """Build a profiler object using the specified timer function.
+
+The default timer is a fast built-in one based on real time.
+For custom timer functions returning integers, 'timeunit' can
+be a float specifying a scale (that is, how long each integer unit
+is, in seconds).
+"""
     def __init__(
         self, timer: Callable[[], float] | None = None, timeunit: float = 0.0, subcalls: bool = True, builtins: bool = True
     ) -> None: ...
-    def getstats(self) -> list[profiler_entry]: ...
+    def getstats(self) -> list[profiler_entry]:
-    def enable(self, subcalls: bool = True, builtins: bool = True) -> None: ...
+        """list of profiler_entry objects.
-    def disable(self) -> None: ...
+
-    def clear(self) -> None: ...
+getstats() -> list of profiler_entry objects
+
+Return all information collected by the profiler.
+Each profiler_entry is a tuple-like object with the
+following attributes:
+
+    code          code object
+    callcount     how many times this was called
+    reccallcount  how many times called recursively
+    totaltime     total time in this entry
+    inlinetime    inline time in this entry (not in subcalls)
+    calls         details of the calls
+
+The calls attribute is either None or a list of
+profiler_subentry objects:
+
+    code          called code object
+    callcount     how many times this is called
+    reccallcount  how many times this is called recursively
+    totaltime     total time spent in this call
+    inlinetime    inline time (not in further subcalls)
+"""
+    def enable(self, subcalls: bool = True, builtins: bool = True) -> None:
+        """Start collecting profiling information.
+
+  subcalls
+    If True, also records for each function
+    statistics separated according to its current caller.
+  builtins
+    If True, records the time spent in
+    built-in functions separately from their caller.
+"""
+    def disable(self) -> None:
+        """Stop collecting profiling information.
+"""
+    def clear(self) -> None:
+        """Clear all profiling information collected so far.
+"""
 
 @final
 class profiler_entry(structseq[Any], tuple[CodeType | str, int, int, float, float, list[profiler_subentry]]):

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

@@ -37,23 +37,92 @@ PRESET_EXTREME: Final[int]  # v big number
 
 @final
 class LZMADecompressor:
+    """Create a decompressor object for decompressing data incrementally.
+
+  format
+    Specifies the container format of the input stream.  If this is
+    FORMAT_AUTO (the default), the decompressor will automatically detect
+    whether the input is FORMAT_XZ or FORMAT_ALONE.  Streams created with
+    FORMAT_RAW cannot be autodetected.
+  memlimit
+    Limit the amount of memory used by the decompressor.  This will cause
+    decompression to fail if the input cannot be decompressed within the
+    given limit.
+  filters
+    A custom filter chain.  This argument is required for FORMAT_RAW, and
+    not accepted with any other format.  When provided, this should be a
+    sequence of dicts, each indicating the ID and options for a single
+    filter.
+
+For one-shot decompression, use the decompress() function instead.
+"""
     if sys.version_info >= (3, 12):
         def __new__(cls, format: int = 0, memlimit: int | None = None, filters: _FilterChain | None = None) -> Self: ...
     else:
         def __init__(self, format: int = 0, memlimit: int | None = None, filters: _FilterChain | None = None) -> None: ...
 
-    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes:
+        """Decompress *data*, returning uncompressed data as bytes.
+
+If *max_length* is nonnegative, returns at most *max_length* bytes of
+decompressed data. If this limit is reached and further output can be
+produced, *self.needs_input* will be set to ``False``. In this case, the next
+call to *decompress()* may provide *data* as b'' to obtain more of the output.
+
+If all of the input data was decompressed and returned (either because this
+was less than *max_length* bytes, or because *max_length* was negative),
+*self.needs_input* will be set to True.
+
+Attempting to decompress data after the end of stream is reached raises an
+EOFError.  Any data found after the end of the stream is ignored and saved in
+the unused_data attribute.
+"""
     @property
-    def check(self) -> int: ...
+    def check(self) -> int:
+        """ID of the integrity check used by the input stream.
+"""
     @property
-    def eof(self) -> bool: ...
+    def eof(self) -> bool:
+        """True if the end-of-stream marker has been reached.
+"""
     @property
-    def unused_data(self) -> bytes: ...
+    def unused_data(self) -> bytes:
+        """Data found after the end of the compressed stream.
+"""
     @property
-    def needs_input(self) -> bool: ...
+    def needs_input(self) -> bool:
+        """True if more input is needed before more decompressed data can be produced.
+"""
 
 @final
 class LZMACompressor:
+    """LZMACompressor(format=FORMAT_XZ, check=-1, preset=None, filters=None)
+
+Create a compressor object for compressing data incrementally.
+
+format specifies the container format to use for the output. This can
+be FORMAT_XZ (default), FORMAT_ALONE, or FORMAT_RAW.
+
+check specifies the integrity check to use. For FORMAT_XZ, the default
+is CHECK_CRC64. FORMAT_ALONE and FORMAT_RAW do not support integrity
+checks; for these formats, check must be omitted, or be CHECK_NONE.
+
+The settings used by the compressor can be specified either as a
+preset compression level (with the 'preset' argument), or in detail
+as a custom filter chain (with the 'filters' argument). For FORMAT_XZ
+and FORMAT_ALONE, the default is to use the PRESET_DEFAULT preset
+level. For FORMAT_RAW, the caller must always specify a filter chain;
+the raw compressor does not support preset compression levels.
+
+preset (if provided) should be an integer in the range 0-9, optionally
+OR-ed with the constant PRESET_EXTREME.
+
+filters (if provided) should be a sequence of dicts. Each dict should
+have an entry for "id" indicating the ID of the filter, plus
+additional entries for options to the filter.
+
+For one-shot compression, use the compress() function instead.
+"""
     if sys.version_info >= (3, 12):
         def __new__(
             cls, format: int = 1, check: int = -1, preset: int | None = None, filters: _FilterChain | None = None
@@ -63,9 +132,28 @@ class LZMACompressor:
             self, format: int = 1, check: int = -1, preset: int | None = None, filters: _FilterChain | None = None
         ) -> None: ...
 
-    def compress(self, data: ReadableBuffer, /) -> bytes: ...
+    def compress(self, data: ReadableBuffer, /) -> bytes:
-    def flush(self) -> bytes: ...
+        """Provide data to the compressor object.
 
-class LZMAError(Exception): ...
+Returns a chunk of compressed data if possible, or b'' otherwise.
 
-def is_check_supported(check_id: int, /) -> bool: ...
+When you have finished providing data to the compressor, call the
+flush() method to finish the compression process.
+"""
+    def flush(self) -> bytes:
+        """Finish the compression process.
+
+Returns the compressed data left in internal buffers.
+
+The compressor object may not be used after this method is called.
+"""
+
+class LZMAError(Exception):
+    """Call to liblzma failed.
+"""
+
+def is_check_supported(check_id: int, /) -> bool:
+    """Test whether the given integrity check is supported.
+
+Always returns True for CHECK_NONE and CHECK_CRC32.
+"""

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

@@ -1,9 +1,20 @@
+"""Shared support for scanning document type declarations in HTML and XHTML.
+
+This module is used as a foundation for the html.parser module.  It has no
+documented public API and should not be used directly.
+
+"""
 import sys
 from typing import Any
 
 class ParserBase:
+    """Parser base class which provides some common support methods used
+by the SGML/HTML and XHTML parsers.
+"""
     def reset(self) -> None: ...
-    def getpos(self) -> tuple[int, int]: ...
+    def getpos(self) -> tuple[int, int]:
+        """Return current line number and offset.
+"""
     def unknown_decl(self, data: str) -> None: ...
     def parse_comment(self, i: int, report: bool = True) -> int: ...  # undocumented
     def parse_declaration(self, i: int) -> int: ...  # undocumented

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

@@ -1,3 +1,11 @@
+"""Operator interface.
+
+This module exports a set of functions implemented in C corresponding
+to the intrinsic operators of Python.  For example, operator.add(x, y)
+is equivalent to the expression x+y.  The function names are those
+used for special methods; variants without leading and trailing
+'__' are also provided for convenience.
+"""
 import sys
 from _typeshed import SupportsGetItem
 from collections.abc import Callable, Container, Iterable, MutableMapping, MutableSequence, Sequence
@@ -47,76 +55,202 @@ class _SupportsPos(Protocol[_T_co]):
     def __pos__(self) -> _T_co: ...
 
 # All four comparison functions must have the same signature, or we get false-positive errors
-def lt(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+def lt(a: _SupportsComparison, b: _SupportsComparison, /) -> Any:
-def le(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+    """Same as a < b.
-def eq(a: object, b: object, /) -> Any: ...
+"""
-def ne(a: object, b: object, /) -> Any: ...
+def le(a: _SupportsComparison, b: _SupportsComparison, /) -> Any:
-def ge(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+    """Same as a <= b.
-def gt(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+"""
-def not_(a: object, /) -> bool: ...
+def eq(a: object, b: object, /) -> Any:
-def truth(a: object, /) -> bool: ...
+    """Same as a == b.
-def is_(a: object, b: object, /) -> bool: ...
+"""
-def is_not(a: object, b: object, /) -> bool: ...
+def ne(a: object, b: object, /) -> Any:
-def abs(a: SupportsAbs[_T], /) -> _T: ...
+    """Same as a != b.
-def add(a: Any, b: Any, /) -> Any: ...
+"""
-def and_(a: Any, b: Any, /) -> Any: ...
+def ge(a: _SupportsComparison, b: _SupportsComparison, /) -> Any:
-def floordiv(a: Any, b: Any, /) -> Any: ...
+    """Same as a >= b.
-def index(a: SupportsIndex, /) -> int: ...
+"""
-def inv(a: _SupportsInversion[_T_co], /) -> _T_co: ...
+def gt(a: _SupportsComparison, b: _SupportsComparison, /) -> Any:
-def invert(a: _SupportsInversion[_T_co], /) -> _T_co: ...
+    """Same as a > b.
-def lshift(a: Any, b: Any, /) -> Any: ...
+"""
-def mod(a: Any, b: Any, /) -> Any: ...
+def not_(a: object, /) -> bool:
-def mul(a: Any, b: Any, /) -> Any: ...
+    """Same as not a.
-def matmul(a: Any, b: Any, /) -> Any: ...
+"""
-def neg(a: _SupportsNeg[_T_co], /) -> _T_co: ...
+def truth(a: object, /) -> bool:
-def or_(a: Any, b: Any, /) -> Any: ...
+    """Return True if a is true, False otherwise.
-def pos(a: _SupportsPos[_T_co], /) -> _T_co: ...
+"""
-def pow(a: Any, b: Any, /) -> Any: ...
+def is_(a: object, b: object, /) -> bool:
-def rshift(a: Any, b: Any, /) -> Any: ...
+    """Same as a is b.
-def sub(a: Any, b: Any, /) -> Any: ...
+"""
-def truediv(a: Any, b: Any, /) -> Any: ...
+def is_not(a: object, b: object, /) -> bool:
-def xor(a: Any, b: Any, /) -> Any: ...
+    """Same as a is not b.
-def concat(a: Sequence[_T], b: Sequence[_T], /) -> Sequence[_T]: ...
+"""
-def contains(a: Container[object], b: object, /) -> bool: ...
+def abs(a: SupportsAbs[_T], /) -> _T:
-def countOf(a: Iterable[object], b: object, /) -> int: ...
+    """Same as abs(a).
+"""
+def add(a: Any, b: Any, /) -> Any:
+    """Same as a + b.
+"""
+def and_(a: Any, b: Any, /) -> Any:
+    """Same as a & b.
+"""
+def floordiv(a: Any, b: Any, /) -> Any:
+    """Same as a // b.
+"""
+def index(a: SupportsIndex, /) -> int:
+    """Same as a.__index__()
+"""
+def inv(a: _SupportsInversion[_T_co], /) -> _T_co:
+    """Same as ~a.
+"""
+def invert(a: _SupportsInversion[_T_co], /) -> _T_co:
+    """Same as ~a.
+"""
+def lshift(a: Any, b: Any, /) -> Any:
+    """Same as a << b.
+"""
+def mod(a: Any, b: Any, /) -> Any:
+    """Same as a % b.
+"""
+def mul(a: Any, b: Any, /) -> Any:
+    """Same as a * b.
+"""
+def matmul(a: Any, b: Any, /) -> Any:
+    """Same as a @ b.
+"""
+def neg(a: _SupportsNeg[_T_co], /) -> _T_co:
+    """Same as -a.
+"""
+def or_(a: Any, b: Any, /) -> Any:
+    """Same as a | b.
+"""
+def pos(a: _SupportsPos[_T_co], /) -> _T_co:
+    """Same as +a.
+"""
+def pow(a: Any, b: Any, /) -> Any:
+    """Same as a ** b.
+"""
+def rshift(a: Any, b: Any, /) -> Any:
+    """Same as a >> b.
+"""
+def sub(a: Any, b: Any, /) -> Any:
+    """Same as a - b.
+"""
+def truediv(a: Any, b: Any, /) -> Any:
+    """Same as a / b.
+"""
+def xor(a: Any, b: Any, /) -> Any:
+    """Same as a ^ b.
+"""
+def concat(a: Sequence[_T], b: Sequence[_T], /) -> Sequence[_T]:
+    """Same as a + b, for a and b sequences.
+"""
+def contains(a: Container[object], b: object, /) -> bool:
+    """Same as b in a (note reversed operands).
+"""
+def countOf(a: Iterable[object], b: object, /) -> int:
+    """Return the number of items in a which are, or which equal, b.
+"""
 @overload
-def delitem(a: MutableSequence[Any], b: SupportsIndex, /) -> None: ...
+def delitem(a: MutableSequence[Any], b: SupportsIndex, /) -> None:
+    """Same as del a[b].
+"""
 @overload
 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: slice, /) -> Sequence[_T]: ...
+def getitem(a: Sequence[_T], b: slice, /) -> Sequence[_T]:
+    """Same as a[b].
+"""
 @overload
 def getitem(a: SupportsGetItem[_K, _V], b: _K, /) -> _V: ...
-def indexOf(a: Iterable[_T], b: _T, /) -> int: ...
+def indexOf(a: Iterable[_T], b: _T, /) -> int:
+    """Return the first index of b in a.
+"""
 @overload
-def setitem(a: MutableSequence[_T], b: SupportsIndex, c: _T, /) -> None: ...
+def setitem(a: MutableSequence[_T], b: SupportsIndex, c: _T, /) -> None:
+    """Same as a[b] = c.
+"""
 @overload
 def setitem(a: MutableSequence[_T], b: slice, c: Sequence[_T], /) -> None: ...
 @overload
 def setitem(a: MutableMapping[_K, _V], b: _K, c: _V, /) -> None: ...
-def length_hint(obj: object, default: int = 0, /) -> int: ...
+def length_hint(obj: object, default: int = 0, /) -> int:
-def iadd(a: Any, b: Any, /) -> Any: ...
+    """Return an estimate of the number of items in obj.
-def iand(a: Any, b: Any, /) -> Any: ...
+
-def iconcat(a: Any, b: Any, /) -> Any: ...
+This is useful for presizing containers when building from an iterable.
-def ifloordiv(a: Any, b: Any, /) -> Any: ...
+
-def ilshift(a: Any, b: Any, /) -> Any: ...
+If the object supports len(), the result will be exact.
-def imod(a: Any, b: Any, /) -> Any: ...
+Otherwise, it may over- or under-estimate by an arbitrary amount.
-def imul(a: Any, b: Any, /) -> Any: ...
+The result will be an integer >= 0.
-def imatmul(a: Any, b: Any, /) -> Any: ...
+"""
-def ior(a: Any, b: Any, /) -> Any: ...
+def iadd(a: Any, b: Any, /) -> Any:
-def ipow(a: Any, b: Any, /) -> Any: ...
+    """Same as a += b.
-def irshift(a: Any, b: Any, /) -> Any: ...
+"""
-def isub(a: Any, b: Any, /) -> Any: ...
+def iand(a: Any, b: Any, /) -> Any:
-def itruediv(a: Any, b: Any, /) -> Any: ...
+    """Same as a &= b.
-def ixor(a: Any, b: Any, /) -> Any: ...
+"""
+def iconcat(a: Any, b: Any, /) -> Any:
+    """Same as a += b, for a and b sequences.
+"""
+def ifloordiv(a: Any, b: Any, /) -> Any:
+    """Same as a //= b.
+"""
+def ilshift(a: Any, b: Any, /) -> Any:
+    """Same as a <<= b.
+"""
+def imod(a: Any, b: Any, /) -> Any:
+    """Same as a %= b.
+"""
+def imul(a: Any, b: Any, /) -> Any:
+    """Same as a *= b.
+"""
+def imatmul(a: Any, b: Any, /) -> Any:
+    """Same as a @= b.
+"""
+def ior(a: Any, b: Any, /) -> Any:
+    """Same as a |= b.
+"""
+def ipow(a: Any, b: Any, /) -> Any:
+    """Same as a **= b.
+"""
+def irshift(a: Any, b: Any, /) -> Any:
+    """Same as a >>= b.
+"""
+def isub(a: Any, b: Any, /) -> Any:
+    """Same as a -= b.
+"""
+def itruediv(a: Any, b: Any, /) -> Any:
+    """Same as a /= b.
+"""
+def ixor(a: Any, b: Any, /) -> Any:
+    """Same as a ^= b.
+"""
 
 if sys.version_info >= (3, 11):
-    def call(obj: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+    def call(obj: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R:
+        """Same as obj(*args, **kwargs).
+"""
 
-def _compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
+def _compare_digest(a: AnyStr, b: AnyStr, /) -> bool:
+    """Return 'a == b'.
+
+This function uses an approach designed to prevent
+timing analysis, making it appropriate for cryptography.
+
+a and b must both be of the same type: either str (ASCII only),
+or any bytes-like object.
+
+Note: If a and b are of different lengths, or if an error occurs,
+a timing attack could theoretically reveal information about the
+types and lengths of a and b--but not their values.
+"""
 
 if sys.version_info >= (3, 14):
-    def is_none(a: object, /) -> TypeIs[None]: ...
+    def is_none(a: object, /) -> TypeIs[None]:
-    def is_not_none(a: _T | None, /) -> TypeIs[_T]: ...
+        """Same as a is None.
+"""
+    def is_not_none(a: _T | None, /) -> TypeIs[_T]:
+        """Same as a is not None.
+"""

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

@@ -1,3 +1,5 @@
+"""Shared OS X support functions.
+"""
 from collections.abc import Iterable, Sequence
 from typing import Final, TypeVar
 
@@ -11,24 +13,90 @@ _UNIVERSAL_CONFIG_VARS: Final[tuple[str, ...]]  # undocumented
 _COMPILER_CONFIG_VARS: Final[tuple[str, ...]]  # undocumented
 _INITPRE: Final[str]  # undocumented
 
-def _find_executable(executable: str, path: str | None = None) -> str | None: ...  # undocumented
+def _find_executable(executable: str, path: str | None = None) -> str | None:  # undocumented
-def _read_output(commandstring: str, capture_stderr: bool = False) -> str | None: ...  # undocumented
+    """Tries to find 'executable' in the directories listed in 'path'.
-def _find_build_tool(toolname: str) -> str: ...  # undocumented
+
+A string listing directories separated by 'os.pathsep'; defaults to
+os.environ['PATH'].  Returns the complete filename or None if not found.
+"""
+def _read_output(commandstring: str, capture_stderr: bool = False) -> str | None:  # undocumented
+    """Output from successful command execution or None
+"""
+def _find_build_tool(toolname: str) -> str:  # undocumented
+    """Find a build tool on current path or using xcrun
+"""
 
 _SYSTEM_VERSION: Final[str | None]  # undocumented
 
-def _get_system_version() -> str: ...  # undocumented
+def _get_system_version() -> str:  # undocumented
-def _remove_original_values(_config_vars: dict[str, str]) -> None: ...  # undocumented
+    """Return the OS X system version as a string
-def _save_modified_value(_config_vars: dict[str, str], cv: str, newvalue: str) -> None: ...  # undocumented
+"""
-def _supports_universal_builds() -> bool: ...  # undocumented
+def _remove_original_values(_config_vars: dict[str, str]) -> None:  # undocumented
-def _find_appropriate_compiler(_config_vars: dict[str, str]) -> dict[str, str]: ...  # undocumented
+    """Remove original unmodified values for testing
-def _remove_universal_flags(_config_vars: dict[str, str]) -> dict[str, str]: ...  # undocumented
+"""
-def _remove_unsupported_archs(_config_vars: dict[str, str]) -> dict[str, str]: ...  # undocumented
+def _save_modified_value(_config_vars: dict[str, str], cv: str, newvalue: str) -> None:  # undocumented
-def _override_all_archs(_config_vars: dict[str, str]) -> dict[str, str]: ...  # undocumented
+    """Save modified and original unmodified value of configuration var
-def _check_for_unavailable_sdk(_config_vars: dict[str, str]) -> dict[str, str]: ...  # undocumented
+"""
-def compiler_fixup(compiler_so: Iterable[str], cc_args: Sequence[str]) -> list[str]: ...
+def _supports_universal_builds() -> bool:  # undocumented
-def customize_config_vars(_config_vars: dict[str, str]) -> dict[str, str]: ...
+    """Returns True if universal builds are supported on this system
-def customize_compiler(_config_vars: dict[str, str]) -> dict[str, str]: ...
+"""
+def _find_appropriate_compiler(_config_vars: dict[str, str]) -> dict[str, str]:  # undocumented
+    """Find appropriate C compiler for extension module builds
+"""
+def _remove_universal_flags(_config_vars: dict[str, str]) -> dict[str, str]:  # undocumented
+    """Remove all universal build arguments from config vars
+"""
+def _remove_unsupported_archs(_config_vars: dict[str, str]) -> dict[str, str]:  # undocumented
+    """Remove any unsupported archs from config vars
+"""
+def _override_all_archs(_config_vars: dict[str, str]) -> dict[str, str]:  # undocumented
+    """Allow override of all archs with ARCHFLAGS env var
+"""
+def _check_for_unavailable_sdk(_config_vars: dict[str, str]) -> dict[str, str]:  # undocumented
+    """Remove references to any SDKs not available
+"""
+def compiler_fixup(compiler_so: Iterable[str], cc_args: Sequence[str]) -> list[str]:
+    """
+This function will strip '-isysroot PATH' and '-arch ARCH' from the
+compile flags if the user has specified one them in extra_compile_flags.
+
+This is needed because '-arch ARCH' adds another architecture to the
+build, without a way to remove an architecture. Furthermore GCC will
+barf if multiple '-isysroot' arguments are present.
+"""
+def customize_config_vars(_config_vars: dict[str, str]) -> dict[str, str]:
+    """Customize Python build configuration variables.
+
+Called internally from sysconfig with a mutable mapping
+containing name/value pairs parsed from the configured
+makefile used to build this interpreter.  Returns
+the mapping updated as needed to reflect the environment
+in which the interpreter is running; in the case of
+a Python from a binary installer, the installed
+environment may be very different from the build
+environment, i.e. different OS levels, different
+built tools, different available CPU architectures.
+
+This customization is performed whenever
+distutils.sysconfig.get_config_vars() is first
+called.  It may be used in environments where no
+compilers are present, i.e. when installing pure
+Python dists.  Customization of compiler paths
+and detection of unavailable archs is deferred
+until the first extension module build is
+requested (in distutils.sysconfig.customize_compiler).
+
+Currently called from distutils.sysconfig
+"""
+def customize_compiler(_config_vars: dict[str, str]) -> dict[str, str]:
+    """Customize compiler path and configuration variables.
+
+This customization is performed when the first
+extension module build is requested
+in distutils.sysconfig.customize_compiler.
+"""
 def get_platform_osx(
     _config_vars: dict[str, str], osname: _T, release: _K, machine: _V
-) -> tuple[str | _T, str | _K, str | _V]: ...
+) -> tuple[str | _T, str | _K, str | _V]:
+    """Filter values for get_platform()
+"""

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

@@ -1,3 +1,5 @@
+"""Optimized C implementation for the Python pickle module.
+"""
 from _typeshed import ReadableBuffer, SupportsWrite
 from collections.abc import Callable, Iterable, Iterator, Mapping
 from pickle import PickleBuffer as PickleBuffer
@@ -26,10 +28,56 @@ def dump(
     *,
     fix_imports: bool = True,
     buffer_callback: _BufferCallback = None,
-) -> None: ...
+) -> None:
+    """Write a pickled representation of obj to the open file object file.
+
+This is equivalent to ``Pickler(file, protocol).dump(obj)``, but may
+be more efficient.
+
+The optional *protocol* argument tells the pickler to use the given
+protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
+protocol is 5. It was introduced in Python 3.8, and is incompatible
+with previous versions.
+
+Specifying a negative protocol version selects the highest protocol
+version supported.  The higher the protocol used, the more recent the
+version of Python needed to read the pickle produced.
+
+The *file* argument must have a write() method that accepts a single
+bytes argument.  It can thus be a file object opened for binary
+writing, an io.BytesIO instance, or any other custom object that meets
+this interface.
+
+If *fix_imports* is True and protocol is less than 3, pickle will try
+to map the new Python 3 names to the old module names used in Python
+2, so that the pickle data stream is readable with Python 2.
+
+If *buffer_callback* is None (the default), buffer views are serialized
+into *file* as part of the pickle stream.  It is an error if
+*buffer_callback* is not None and *protocol* is None or smaller than 5.
+"""
 def dumps(
     obj: Any, protocol: int | None = None, *, fix_imports: bool = True, buffer_callback: _BufferCallback = None
-) -> bytes: ...
+) -> bytes:
+    """Return the pickled representation of the object as a bytes object.
+
+The optional *protocol* argument tells the pickler to use the given
+protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
+protocol is 5. It was introduced in Python 3.8, and is incompatible
+with previous versions.
+
+Specifying a negative protocol version selects the highest protocol
+version supported.  The higher the protocol used, the more recent the
+version of Python needed to read the pickle produced.
+
+If *fix_imports* is True and *protocol* is less than 3, pickle will
+try to map the new Python 3 names to the old module names used in
+Python 2, so that the pickle data stream is readable with Python 2.
+
+If *buffer_callback* is None (the default), buffer views are serialized
+into *file* as part of the pickle stream.  It is an error if
+*buffer_callback* is not None and *protocol* is None or smaller than 5.
+"""
 def load(
     file: _ReadableFileobj,
     *,
@@ -37,7 +85,31 @@ def load(
     encoding: str = "ASCII",
     errors: str = "strict",
     buffers: Iterable[Any] | None = (),
-) -> Any: ...
+) -> Any:
+    """Read and return an object from the pickle data stored in a file.
+
+This is equivalent to ``Unpickler(file).load()``, but may be more
+efficient.
+
+The protocol version of the pickle is detected automatically, so no
+protocol argument is needed.  Bytes past the pickled object's
+representation are ignored.
+
+The argument *file* must have two methods, a read() method that takes
+an integer argument, and a readline() method that requires no
+arguments.  Both methods should return bytes.  Thus *file* can be a
+binary file object opened for reading, an io.BytesIO object, or any
+other custom object that meets this interface.
+
+Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
+which are used to control compatibility support for pickle stream
+generated by Python 2.  If *fix_imports* is True, pickle will try to
+map the old Python 2 names to the new names used in Python 3.  The
+*encoding* and *errors* tell pickle how to decode 8-bit string
+instances pickled by Python 2; these default to 'ASCII' and 'strict',
+respectively.  The *encoding* can be 'bytes' to read these 8-bit
+string instances as bytes objects.
+"""
 def loads(
     data: ReadableBuffer,
     /,
@@ -46,7 +118,22 @@ def loads(
     encoding: str = "ASCII",
     errors: str = "strict",
     buffers: Iterable[Any] | None = (),
-) -> Any: ...
+) -> Any:
+    """Read and return an object from the given pickle data.
+
+The protocol version of the pickle is detected automatically, so no
+protocol argument is needed.  Bytes past the pickled object's
+representation are ignored.
+
+Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
+which are used to control compatibility support for pickle stream
+generated by Python 2.  If *fix_imports* is True, pickle will try to
+map the old Python 2 names to the new names used in Python 3.  The
+*encoding* and *errors* tell pickle how to decode 8-bit string
+instances pickled by Python 2; these default to 'ASCII' and 'strict',
+respectively.  The *encoding* can be 'bytes' to read these 8-bit
+string instances as bytes objects.
+"""
 
 class PickleError(Exception): ...
 class PicklingError(PickleError): ...
@@ -59,6 +146,37 @@ class PicklerMemoProxy:
 
 @disjoint_base
 class Pickler:
+    """This takes a binary file for writing a pickle data stream.
+
+The optional *protocol* argument tells the pickler to use the given
+protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
+protocol is 5. It was introduced in Python 3.8, and is incompatible
+with previous versions.
+
+Specifying a negative protocol version selects the highest protocol
+version supported.  The higher the protocol used, the more recent the
+version of Python needed to read the pickle produced.
+
+The *file* argument must have a write() method that accepts a single
+bytes argument. It can thus be a file object opened for binary
+writing, an io.BytesIO instance, or any other custom object that meets
+this interface.
+
+If *fix_imports* is True and protocol is less than 3, pickle will try
+to map the new Python 3 names to the old module names used in Python
+2, so that the pickle data stream is readable with Python 2.
+
+If *buffer_callback* is None (the default), buffer views are
+serialized into *file* as part of the pickle stream.
+
+If *buffer_callback* is not None, then it can be called any number
+of times with a buffer view.  If the callback returns a false value
+(such as None), the given buffer is out-of-band; otherwise the
+buffer is serialized in-band, i.e. inside the pickle stream.
+
+It is an error if *buffer_callback* is not None and *protocol*
+is None or smaller than 5.
+"""
     fast: bool
     dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
     reducer_override: Callable[[Any], Any]
@@ -74,8 +192,17 @@ class Pickler:
     def memo(self) -> PicklerMemoProxy: ...
     @memo.setter
     def memo(self, value: PicklerMemoProxy | dict[int, tuple[int, Any]]) -> None: ...
-    def dump(self, obj: Any, /) -> None: ...
+    def dump(self, obj: Any, /) -> None:
-    def clear_memo(self) -> None: ...
+        """Write a pickled representation of the given object to the open file.
+"""
+    def clear_memo(self) -> None:
+        """Clears the pickler's "memo".
+
+The memo is the data structure that remembers which objects the
+pickler has already seen, so that shared or recursive objects are
+pickled by reference and not by value.  This method is useful when
+re-using picklers.
+"""
 
     # this method has no default implementation for Python < 3.13
     def persistent_id(self, obj: Any, /) -> Any: ...
@@ -87,6 +214,27 @@ class UnpicklerMemoProxy:
 
 @disjoint_base
 class Unpickler:
+    """This takes a binary file for reading a pickle data stream.
+
+The protocol version of the pickle is detected automatically, so no
+protocol argument is needed.  Bytes past the pickled object's
+representation are ignored.
+
+The argument *file* must have two methods, a read() method that takes
+an integer argument, and a readline() method that requires no
+arguments.  Both methods should return bytes.  Thus *file* can be a
+binary file object opened for reading, an io.BytesIO object, or any
+other custom object that meets this interface.
+
+Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
+which are used to control compatibility support for pickle stream
+generated by Python 2.  If *fix_imports* is True, pickle will try to
+map the old Python 2 names to the new names used in Python 3.  The
+*encoding* and *errors* tell pickle how to decode 8-bit string
+instances pickled by Python 2; these default to 'ASCII' and 'strict',
+respectively.  The *encoding* can be 'bytes' to read these 8-bit
+string instances as bytes objects.
+"""
     def __init__(
         self,
         file: _ReadableFileobj,
@@ -100,8 +248,23 @@ class Unpickler:
     def memo(self) -> UnpicklerMemoProxy: ...
     @memo.setter
     def memo(self, value: UnpicklerMemoProxy | dict[int, tuple[int, Any]]) -> None: ...
-    def load(self) -> Any: ...
+    def load(self) -> Any:
-    def find_class(self, module_name: str, global_name: str, /) -> Any: ...
+        """Load a pickle.
+
+Read a pickled object representation from the open file object given
+in the constructor, and return the reconstituted object hierarchy
+specified therein.
+"""
+    def find_class(self, module_name: str, global_name: str, /) -> Any:
+        """Return an object from a specified module.
+
+If necessary, the module will be imported. Subclasses may override
+this method (e.g. to restrict unpickling of arbitrary classes and
+functions).
+
+This method is called whenever a class or a function object is
+needed.  Both arguments passed are str objects.
+"""
 
     # this method has no default implementation for Python < 3.13
     def persistent_load(self, pid: Any, /) -> Any: ...

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

@@ -1,3 +1,5 @@
+"""A POSIX helper for the subprocess module.
+"""
 import sys
 from _typeshed import StrOrBytesPath
 from collections.abc import Callable, Sequence
@@ -29,7 +31,29 @@ if sys.platform != "win32":
             child_umask: int,
             preexec_fn: Callable[[], None],
             /,
-        ) -> int: ...
+        ) -> int:
+            """Spawn a fresh new child process.
+
+Fork a child process, close parent file descriptors as appropriate in the
+child and duplicate the few that are needed before calling exec() in the
+child process.
+
+If close_fds is True, close file descriptors 3 and higher, except those listed
+in the sorted tuple pass_fds.
+
+The preexec_fn, if supplied, will be called immediately before closing file
+descriptors and exec.
+
+WARNING: preexec_fn is NOT SAFE if your application uses threads.
+         It may trigger infrequent, difficult to debug deadlocks.
+
+If an error occurs in the child process before the exec, it is
+serialized and written to the errpipe_write fd per subprocess.py.
+
+Returns: the child process's PID.
+
+Raises: Only on an error in the parent process.
+"""
     else:
         def fork_exec(
             args: Sequence[StrOrBytesPath] | None,
@@ -56,4 +80,26 @@ if sys.platform != "win32":
             preexec_fn: Callable[[], None],
             allow_vfork: bool,
             /,
-        ) -> int: ...
+        ) -> int:
+            """Spawn a fresh new child process.
+
+Fork a child process, close parent file descriptors as appropriate in the
+child and duplicate the few that are needed before calling exec() in the
+child process.
+
+If close_fds is True, close file descriptors 3 and higher, except those listed
+in the sorted tuple pass_fds.
+
+The preexec_fn, if supplied, will be called immediately before closing file
+descriptors and exec.
+
+WARNING: preexec_fn is NOT SAFE if your application uses threads.
+         It may trigger infrequent, difficult to debug deadlocks.
+
+If an error occurs in the child process before the exec, it is
+serialized and written to the errpipe_write fd per subprocess.py.
+
+Returns: the child process's PID.
+
+Raises: Only on an error in the parent process.
+"""

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

@@ -5,10 +5,32 @@ _T = TypeVar("_T")
 
 _CacheToken = NewType("_CacheToken", int)
 
-def get_cache_token() -> _CacheToken: ...
+def get_cache_token() -> _CacheToken:
+    """Returns the current ABC cache token.
+
+The token is an opaque object (supporting equality testing) identifying the
+current version of the ABC cache for virtual subclasses. The token changes
+with every call to ``register()`` on any ABC.
+"""
 
 class ABCMeta(type):
+    """Metaclass for defining Abstract Base Classes (ABCs).
+
+Use this metaclass to create an ABC.  An ABC can be subclassed
+directly, and then acts as a mix-in class.  You can also register
+unrelated concrete classes (even built-in classes) and unrelated
+ABCs as 'virtual subclasses' -- these and their descendants will
+be considered subclasses of the registering ABC by the built-in
+issubclass() function, but the registering ABC won't show up in
+their MRO (Method Resolution Order) nor will method
+implementations defined by the registering ABC be callable (not
+even via super()).
+"""
     def __new__(
         mcls: type[_typeshed.Self], name: str, bases: tuple[type[Any], ...], namespace: dict[str, Any], /
     ) -> _typeshed.Self: ...
-    def register(cls, subclass: type[_T]) -> type[_T]: ...
+    def register(cls, subclass: type[_T]) -> type[_T]:
+        """Register a virtual subclass of an ABC.
+
+Returns the subclass, to allow usage as a class decorator.
+"""

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

@@ -1,3 +1,5 @@
+"""Python decimal arithmetic module
+"""
 # This is a slight lie, the implementations aren't exactly identical
 # However, in all likelihood, the differences are inconsequential
 import sys

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

@@ -1,18 +1,56 @@
+"""C implementation of the Python queue module.
+This module is an implementation detail, please do not use it directly.
+"""
 from types import GenericAlias
 from typing import Any, Generic, TypeVar
 from typing_extensions import disjoint_base
 
 _T = TypeVar("_T")
 
-class Empty(Exception): ...
+class Empty(Exception):
+    """Exception raised by Queue.get(block=0)/get_nowait().
+"""
 
 @disjoint_base
 class SimpleQueue(Generic[_T]):
+    """Simple, unbounded, reentrant FIFO queue.
+"""
     def __init__(self) -> None: ...
-    def empty(self) -> bool: ...
+    def empty(self) -> bool:
-    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
+        """Return True if the queue is empty, False otherwise (not reliable!).
-    def get_nowait(self) -> _T: ...
+"""
-    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
+    def get(self, block: bool = True, timeout: float | None = None) -> _T:
-    def put_nowait(self, item: _T) -> None: ...
+        """Remove and return an item from the queue.
-    def qsize(self) -> int: ...
+
-    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+If optional args 'block' is true and 'timeout' is None (the default),
+block if necessary until an item is available. If 'timeout' is
+a non-negative number, it blocks at most 'timeout' seconds and raises
+the Empty exception if no item was available within that time.
+Otherwise ('block' is false), return an item if one is immediately
+available, else raise the Empty exception ('timeout' is ignored
+in that case).
+"""
+    def get_nowait(self) -> _T:
+        """Remove and return an item from the queue without blocking.
+
+Only get an item if one is immediately available. Otherwise
+raise the Empty exception.
+"""
+    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None:
+        """Put the item on the queue.
+
+The optional 'block' and 'timeout' arguments are ignored, as this method
+never blocks.  They are provided for compatibility with the Queue class.
+"""
+    def put_nowait(self, item: _T) -> None:
+        """Put an item into the queue without blocking.
+
+This is exactly equivalent to `put(item)` and is only provided
+for compatibility with the Queue class.
+"""
+    def qsize(self) -> int:
+        """Return the approximate size of the queue (not reliable!).
+"""
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+        """See PEP 585
+"""

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

@@ -1,3 +1,5 @@
+"""Module implements the Mersenne Twister random number generator.
+"""
 import sys
 from typing_extensions import Self, TypeAlias, disjoint_base
 
@@ -6,13 +8,28 @@ _State: TypeAlias = tuple[int, ...]
 
 @disjoint_base
 class Random:
+    """Random() -> create a random number generator with its own internal state.
+"""
     if sys.version_info >= (3, 10):
         def __init__(self, seed: object = ..., /) -> None: ...
     else:
         def __new__(self, seed: object = ..., /) -> Self: ...
 
-    def seed(self, n: object = None, /) -> None: ...
+    def seed(self, n: object = None, /) -> None:
-    def getstate(self) -> _State: ...
+        """seed([n]) -> None.
-    def setstate(self, state: _State, /) -> None: ...
+
-    def random(self) -> float: ...
+Defaults to use urandom and falls back to a combination
-    def getrandbits(self, k: int, /) -> int: ...
+of the current time and the process identifier.
+"""
+    def getstate(self) -> _State:
+        """getstate() -> tuple containing the current state.
+"""
+    def setstate(self, state: _State, /) -> None:
+        """setstate(state) -> None.  Restores generator state.
+"""
+    def random(self) -> float:
+        """random() -> x in the interval [0, 1).
+"""
+    def getrandbits(self, k: int, /) -> int:
+        """getrandbits(k) -> x.  Generates an int with k random bits.
+"""

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

@@ -1,3 +1,6 @@
+"""
+The objects used by the site module to add custom builtins.
+"""
 import sys
 from collections.abc import Iterable
 from typing import ClassVar, Literal, NoReturn
@@ -9,9 +12,20 @@ class Quitter:
     def __call__(self, code: sys._ExitCode = None) -> NoReturn: ...
 
 class _Printer:
+    """interactive prompt objects for printing the license text, a list of
+contributors and the copyright notice.
+"""
     MAXLINES: ClassVar[Literal[23]]
     def __init__(self, name: str, data: str, files: Iterable[str] = (), dirs: Iterable[str] = ()) -> None: ...
     def __call__(self) -> None: ...
 
 class _Helper:
+    """Define the builtin 'help'.
+
+This is a wrapper around pydoc.help that provides a helpful message
+when 'help' is typed at the Python interactive prompt.
+
+Calling help() at the Python prompt starts an interactive help session.
+Calling help(thing) prints help for the python object 'thing'.
+"""
     def __call__(self, request: object = ...) -> None: ...

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

@@ -1,3 +1,7 @@
+"""Implementation module for socket operations.
+
+See the socket module for documentation.
+"""
 import sys
 from _typeshed import ReadableBuffer, WriteableBuffer
 from collections.abc import Iterable
@@ -733,15 +737,68 @@ if sys.platform != "win32" and sys.platform != "darwin":
 
 @disjoint_base
 class socket:
+    """socket(family=AF_INET, type=SOCK_STREAM, proto=0) -> socket object
+socket(family=-1, type=-1, proto=-1, fileno=None) -> socket object
+
+Open a socket of the given type.  The family argument specifies the
+address family; it defaults to AF_INET.  The type argument specifies
+whether this is a stream (SOCK_STREAM, this is the default)
+or datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,
+specifying the default protocol.  Keyword arguments are accepted.
+The socket is created as non-inheritable.
+
+When a fileno is passed in, family, type and proto are auto-detected,
+unless they are explicitly set.
+
+A socket object represents one endpoint of a network connection.
+
+Methods of socket objects (keyword arguments not allowed):
+
+_accept() -- accept connection, returning new socket fd and client address
+bind(addr) -- bind the socket to a local address
+close() -- close the socket
+connect(addr) -- connect the socket to a remote address
+connect_ex(addr) -- connect, return an error code instead of an exception
+dup() -- return a new socket fd duplicated from fileno()
+fileno() -- return underlying file descriptor
+getpeername() -- return remote address [*]
+getsockname() -- return local address
+getsockopt(level, optname[, buflen]) -- get socket options
+gettimeout() -- return timeout or None
+listen([n]) -- start listening for incoming connections
+recv(buflen[, flags]) -- receive data
+recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)
+recvfrom(buflen[, flags]) -- receive data and sender's address
+recvfrom_into(buffer[, nbytes, [, flags])
+  -- receive data and sender's address (into a buffer)
+sendall(data[, flags]) -- send all data
+send(data[, flags]) -- send data, may not send all of it
+sendto(data[, flags], addr) -- send data to a given address
+setblocking(bool) -- set or clear the blocking I/O flag
+getblocking() -- return True if socket is blocking, False if non-blocking
+setsockopt(level, optname, value[, optlen]) -- set socket options
+settimeout(None | float) -- set or clear the timeout
+shutdown(how) -- shut down traffic in one or both directions
+
+ [*] not available on all platforms!
+"""
     @property
-    def family(self) -> int: ...
+    def family(self) -> int:
+        """the socket family
+"""
     @property
-    def type(self) -> int: ...
+    def type(self) -> int:
+        """the socket type
+"""
     @property
-    def proto(self) -> int: ...
+    def proto(self) -> int:
+        """the socket protocol
+"""
     # F811: "Redefinition of unused `timeout`"
     @property
-    def timeout(self) -> float | None: ...  # noqa: F811
+    def timeout(self) -> float | None:  # noqa: F811
+        """the socket timeout
+"""
     if sys.platform == "win32":
         def __init__(
             self, family: int = ..., type: int = ..., proto: int = ..., fileno: SupportsIndex | bytes | None = None
@@ -749,38 +806,205 @@ class socket:
     else:
         def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: SupportsIndex | None = None) -> None: ...
 
-    def bind(self, address: _Address, /) -> None: ...
+    def bind(self, address: _Address, /) -> None:
-    def close(self) -> None: ...
+        """bind(address)
-    def connect(self, address: _Address, /) -> None: ...
+
-    def connect_ex(self, address: _Address, /) -> int: ...
+Bind the socket to a local address.  For IP sockets, the address is a
-    def detach(self) -> int: ...
+pair (host, port); the host must refer to the local host. For raw packet
-    def fileno(self) -> int: ...
+sockets the address is a tuple (ifname, proto [,pkttype [,hatype [,addr]]])
-    def getpeername(self) -> _RetAddress: ...
+"""
-    def getsockname(self) -> _RetAddress: ...
+    def close(self) -> None:
+        """close()
+
+Close the socket.  It cannot be used after this call.
+"""
+    def connect(self, address: _Address, /) -> None:
+        """connect(address)
+
+Connect the socket to a remote address.  For IP sockets, the address
+is a pair (host, port).
+"""
+    def connect_ex(self, address: _Address, /) -> int:
+        """connect_ex(address) -> errno
+
+This is like connect(address), but returns an error code (the errno value)
+instead of raising an exception when an error occurs.
+"""
+    def detach(self) -> int:
+        """detach()
+
+Close the socket object without closing the underlying file descriptor.
+The object cannot be used after this call, but the file descriptor
+can be reused for other purposes.  The file descriptor is returned.
+"""
+    def fileno(self) -> int:
+        """fileno() -> integer
+
+Return the integer file descriptor of the socket.
+"""
+    def getpeername(self) -> _RetAddress:
+        """getpeername() -> address info
+
+Return the address of the remote endpoint.  For IP sockets, the address
+info is a pair (hostaddr, port).
+"""
+    def getsockname(self) -> _RetAddress:
+        """getsockname() -> address info
+
+Return the address of the local endpoint. The format depends on the
+address family. For IPv4 sockets, the address info is a pair
+(hostaddr, port). For IPv6 sockets, the address info is a 4-tuple
+(hostaddr, port, flowinfo, scope_id).
+"""
     @overload
-    def getsockopt(self, level: int, optname: int, /) -> int: ...
+    def getsockopt(self, level: int, optname: int, /) -> int:
+        """getsockopt(level, option[, buffersize]) -> value
+
+Get a socket option.  See the Unix manual for level and option.
+If a nonzero buffersize argument is given, the return value is a
+string of that length; otherwise it is an integer.
+"""
     @overload
     def getsockopt(self, level: int, optname: int, buflen: int, /) -> bytes: ...
-    def getblocking(self) -> bool: ...
+    def getblocking(self) -> bool:
-    def gettimeout(self) -> float | None: ...
+        """getblocking()
+
+Returns True if socket is in blocking mode, or False if it
+is in non-blocking mode.
+"""
+    def gettimeout(self) -> float | None:
+        """gettimeout() -> timeout
+
+Returns the timeout in seconds (float) associated with socket
+operations. A timeout of None indicates that timeouts on socket
+operations are disabled.
+"""
     if sys.platform == "win32":
         def ioctl(self, control: int, option: int | tuple[int, int, int] | bool, /) -> None: ...
 
-    def listen(self, backlog: int = ..., /) -> None: ...
+    def listen(self, backlog: int = ..., /) -> None:
-    def recv(self, bufsize: int, flags: int = 0, /) -> bytes: ...
+        """listen([backlog])
-    def recvfrom(self, bufsize: int, flags: int = 0, /) -> tuple[bytes, _RetAddress]: ...
+
+Enable a server to accept connections.  If backlog is specified, it must be
+at least 0 (if it is lower, it is set to 0); it specifies the number of
+unaccepted connections that the system will allow before refusing new
+connections. If not specified, a default reasonable value is chosen.
+"""
+    def recv(self, bufsize: int, flags: int = 0, /) -> bytes:
+        """recv(buffersize[, flags]) -> data
+
+Receive up to buffersize bytes from the socket.  For the optional flags
+argument, see the Unix manual.  When no data is available, block until
+at least one byte is available or until the remote end is closed.  When
+the remote end is closed and all data is read, return the empty string.
+"""
+    def recvfrom(self, bufsize: int, flags: int = 0, /) -> tuple[bytes, _RetAddress]:
+        """recvfrom(buffersize[, flags]) -> (data, address info)
+
+Like recv(buffersize, flags) but also return the sender's address info.
+"""
     if sys.platform != "win32":
-        def recvmsg(self, bufsize: int, ancbufsize: int = 0, flags: int = 0, /) -> tuple[bytes, list[_CMSG], int, Any]: ...
+        def recvmsg(self, bufsize: int, ancbufsize: int = 0, flags: int = 0, /) -> tuple[bytes, list[_CMSG], int, Any]:
+            """recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)
+
+Receive normal data (up to bufsize bytes) and ancillary data from the
+socket.  The ancbufsize argument sets the size in bytes of the
+internal buffer used to receive the ancillary data; it defaults to 0,
+meaning that no ancillary data will be received.  Appropriate buffer
+sizes for ancillary data can be calculated using CMSG_SPACE() or
+CMSG_LEN(), and items which do not fit into the buffer might be
+truncated or discarded.  The flags argument defaults to 0 and has the
+same meaning as for recv().
+
+The return value is a 4-tuple: (data, ancdata, msg_flags, address).
+The data item is a bytes object holding the non-ancillary data
+received.  The ancdata item is a list of zero or more tuples
+(cmsg_level, cmsg_type, cmsg_data) representing the ancillary data
+(control messages) received: cmsg_level and cmsg_type are integers
+specifying the protocol level and protocol-specific type respectively,
+and cmsg_data is a bytes object holding the associated data.  The
+msg_flags item is the bitwise OR of various flags indicating
+conditions on the received message; see your system documentation for
+details.  If the receiving socket is unconnected, address is the
+address of the sending socket, if available; otherwise, its value is
+unspecified.
+
+If recvmsg() raises an exception after the system call returns, it
+will first attempt to close any file descriptors received via the
+SCM_RIGHTS mechanism.
+"""
         def recvmsg_into(
             self, buffers: Iterable[WriteableBuffer], ancbufsize: int = 0, flags: int = 0, /
-        ) -> tuple[int, list[_CMSG], int, Any]: ...
+        ) -> tuple[int, list[_CMSG], int, Any]:
+            """recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)
 
-    def recvfrom_into(self, buffer: WriteableBuffer, nbytes: int = 0, flags: int = 0) -> tuple[int, _RetAddress]: ...
+Receive normal data and ancillary data from the socket, scattering the
-    def recv_into(self, buffer: WriteableBuffer, nbytes: int = 0, flags: int = 0) -> int: ...
+non-ancillary data into a series of buffers.  The buffers argument
-    def send(self, data: ReadableBuffer, flags: int = 0, /) -> int: ...
+must be an iterable of objects that export writable buffers
-    def sendall(self, data: ReadableBuffer, flags: int = 0, /) -> None: ...
+(e.g. bytearray objects); these will be filled with successive chunks
+of the non-ancillary data until it has all been written or there are
+no more buffers.  The ancbufsize argument sets the size in bytes of
+the internal buffer used to receive the ancillary data; it defaults to
+0, meaning that no ancillary data will be received.  Appropriate
+buffer sizes for ancillary data can be calculated using CMSG_SPACE()
+or CMSG_LEN(), and items which do not fit into the buffer might be
+truncated or discarded.  The flags argument defaults to 0 and has the
+same meaning as for recv().
+
+The return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).
+The nbytes item is the total number of bytes of non-ancillary data
+written into the buffers.  The ancdata item is a list of zero or more
+tuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary
+data (control messages) received: cmsg_level and cmsg_type are
+integers specifying the protocol level and protocol-specific type
+respectively, and cmsg_data is a bytes object holding the associated
+data.  The msg_flags item is the bitwise OR of various flags
+indicating conditions on the received message; see your system
+documentation for details.  If the receiving socket is unconnected,
+address is the address of the sending socket, if available; otherwise,
+its value is unspecified.
+
+If recvmsg_into() raises an exception after the system call returns,
+it will first attempt to close any file descriptors received via the
+SCM_RIGHTS mechanism.
+"""
+
+    def recvfrom_into(self, buffer: WriteableBuffer, nbytes: int = 0, flags: int = 0) -> tuple[int, _RetAddress]:
+        """recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)
+
+Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.
+"""
+    def recv_into(self, buffer: WriteableBuffer, nbytes: int = 0, flags: int = 0) -> int:
+        """recv_into(buffer, [nbytes[, flags]]) -> nbytes_read
+
+A version of recv() that stores its data into a buffer rather than creating
+a new string.  Receive up to buffersize bytes from the socket.  If buffersize
+is not specified (or 0), receive up to the size available in the given buffer.
+
+See recv() for documentation about the flags.
+"""
+    def send(self, data: ReadableBuffer, flags: int = 0, /) -> int:
+        """send(data[, flags]) -> count
+
+Send a data string to the socket.  For the optional flags
+argument, see the Unix manual.  Return the number of bytes
+sent; this may be less than len(data) if the network is busy.
+"""
+    def sendall(self, data: ReadableBuffer, flags: int = 0, /) -> None:
+        """sendall(data[, flags])
+
+Send a data string to the socket.  For the optional flags
+argument, see the Unix manual.  This calls send() repeatedly
+until all data is sent.  If an error occurs, it's impossible
+to tell how much data has been sent.
+"""
     @overload
-    def sendto(self, data: ReadableBuffer, address: _Address, /) -> int: ...
+    def sendto(self, data: ReadableBuffer, address: _Address, /) -> int:
+        """sendto(data[, flags], address) -> count
+
+Like send(data, flags) but allows specifying the destination address.
+For IP sockets, the address is a pair (hostaddr, port).
+"""
     @overload
     def sendto(self, data: ReadableBuffer, flags: int, address: _Address, /) -> int: ...
     if sys.platform != "win32":
@@ -791,68 +1015,243 @@ class socket:
             flags: int = 0,
             address: _Address | None = None,
             /,
-        ) -> int: ...
+        ) -> int:
+            """sendmsg(buffers[, ancdata[, flags[, address]]]) -> count
+
+Send normal and ancillary data to the socket, gathering the
+non-ancillary data from a series of buffers and concatenating it into
+a single message.  The buffers argument specifies the non-ancillary
+data as an iterable of bytes-like objects (e.g. bytes objects).
+The ancdata argument specifies the ancillary data (control messages)
+as an iterable of zero or more tuples (cmsg_level, cmsg_type,
+cmsg_data), where cmsg_level and cmsg_type are integers specifying the
+protocol level and protocol-specific type respectively, and cmsg_data
+is a bytes-like object holding the associated data.  The flags
+argument defaults to 0 and has the same meaning as for send().  If
+address is supplied and not None, it sets a destination address for
+the message.  The return value is the number of bytes of non-ancillary
+data sent.
+"""
     if sys.platform == "linux":
         def sendmsg_afalg(
             self, msg: Iterable[ReadableBuffer] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = 0
-        ) -> int: ...
+        ) -> int:
+            """sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags=MSG_MORE]]])
 
-    def setblocking(self, flag: bool, /) -> None: ...
+Set operation mode, IV and length of associated data for an AF_ALG
-    def settimeout(self, value: float | None, /) -> None: ...
+operation socket.
+"""
+
+    def setblocking(self, flag: bool, /) -> None:
+        """setblocking(flag)
+
+Set the socket to blocking (flag is true) or non-blocking (false).
+setblocking(True) is equivalent to settimeout(None);
+setblocking(False) is equivalent to settimeout(0.0).
+"""
+    def settimeout(self, value: float | None, /) -> None:
+        """settimeout(timeout)
+
+Set a timeout on socket operations.  'timeout' can be a float,
+giving in seconds, or None.  Setting a timeout of None disables
+the timeout feature and is equivalent to setblocking(1).
+Setting a timeout of zero is the same as setblocking(0).
+"""
     @overload
-    def setsockopt(self, level: int, optname: int, value: int | ReadableBuffer, /) -> None: ...
+    def setsockopt(self, level: int, optname: int, value: int | ReadableBuffer, /) -> None:
+        """setsockopt(level, option, value: int)
+setsockopt(level, option, value: buffer)
+setsockopt(level, option, None, optlen: int)
+
+Set a socket option.  See the Unix manual for level and option.
+The value argument can either be an integer, a string buffer, or
+None, optlen.
+"""
     @overload
     def setsockopt(self, level: int, optname: int, value: None, optlen: int, /) -> None: ...
     if sys.platform == "win32":
         def share(self, process_id: int, /) -> bytes: ...
 
-    def shutdown(self, how: int, /) -> None: ...
+    def shutdown(self, how: int, /) -> None:
+        """shutdown(flag)
+
+Shut down the reading side of the socket (flag == SHUT_RD), the writing side
+of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).
+"""
 
 SocketType = socket
 
 # ===== Functions =====
 
-def close(fd: SupportsIndex, /) -> None: ...
+def close(fd: SupportsIndex, /) -> None:
-def dup(fd: SupportsIndex, /) -> int: ...
+    """close(integer) -> None
+
+Close an integer socket file descriptor.  This is like os.close(), but for
+sockets; on some platforms os.close() won't work for socket file descriptors.
+"""
+def dup(fd: SupportsIndex, /) -> int:
+    """dup(integer) -> integer
+
+Duplicate an integer socket file descriptor.  This is like os.dup(), but for
+sockets; on some platforms os.dup() won't work for socket file descriptors.
+"""
 
 # the 5th tuple item is an address
 def getaddrinfo(
     host: bytes | str | None, port: bytes | str | int | None, family: int = ..., type: int = 0, proto: int = 0, flags: int = 0
-) -> list[tuple[int, int, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]: ...
+) -> list[tuple[int, int, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]:
-def gethostbyname(hostname: str, /) -> str: ...
+    """getaddrinfo(host, port [, family, type, proto, flags])
-def gethostbyname_ex(hostname: str, /) -> tuple[str, list[str], list[str]]: ...
+    -> list of (family, type, proto, canonname, sockaddr)
-def gethostname() -> str: ...
+
-def gethostbyaddr(ip_address: str, /) -> tuple[str, list[str], list[str]]: ...
+Resolve host and port into addrinfo struct.
-def getnameinfo(sockaddr: tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], flags: int, /) -> tuple[str, str]: ...
+"""
-def getprotobyname(protocolname: str, /) -> int: ...
+def gethostbyname(hostname: str, /) -> str:
-def getservbyname(servicename: str, protocolname: str = ..., /) -> int: ...
+    """gethostbyname(host) -> address
-def getservbyport(port: int, protocolname: str = ..., /) -> str: ...
+
-def ntohl(x: int, /) -> int: ...  # param & ret val are 32-bit ints
+Return the IP address (a string of the form '255.255.255.255') for a host.
-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 gethostbyname_ex(hostname: str, /) -> tuple[str, list[str], list[str]]:
-def htons(x: int, /) -> int: ...  # param & ret val are 16-bit ints
+    """gethostbyname_ex(host) -> (name, aliaslist, addresslist)
-def inet_aton(ip_addr: str, /) -> bytes: ...  # ret val 4 bytes in length
+
-def inet_ntoa(packed_ip: ReadableBuffer, /) -> str: ...
+Return the true host name, a list of aliases, and a list of IP addresses,
-def inet_pton(address_family: int, ip_string: str, /) -> bytes: ...
+for a host.  The host argument is a string giving a host name or IP number.
-def inet_ntop(address_family: int, packed_ip: ReadableBuffer, /) -> str: ...
+"""
-def getdefaulttimeout() -> float | None: ...
+def gethostname() -> str:
+    """gethostname() -> string
+
+Return the current host name.
+"""
+def gethostbyaddr(ip_address: str, /) -> tuple[str, list[str], list[str]]:
+    """gethostbyaddr(host) -> (name, aliaslist, addresslist)
+
+Return the true host name, a list of aliases, and a list of IP addresses,
+for a host.  The host argument is a string giving a host name or IP number.
+"""
+def getnameinfo(sockaddr: tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], flags: int, /) -> tuple[str, str]:
+    """getnameinfo(sockaddr, flags) --> (host, port)
+
+Get host and port for a sockaddr.
+"""
+def getprotobyname(protocolname: str, /) -> int:
+    """getprotobyname(name) -> integer
+
+Return the protocol number for the named protocol.  (Rarely used.)
+"""
+def getservbyname(servicename: str, protocolname: str = ..., /) -> int:
+    """getservbyname(servicename[, protocolname]) -> integer
+
+Return a port number from a service name and protocol name.
+The optional protocol name, if given, should be 'tcp' or 'udp',
+otherwise any protocol will match.
+"""
+def getservbyport(port: int, protocolname: str = ..., /) -> str:
+    """getservbyport(port[, protocolname]) -> string
+
+Return the service name from a port number and protocol name.
+The optional protocol name, if given, should be 'tcp' or 'udp',
+otherwise any protocol will match.
+"""
+def ntohl(x: int, /) -> int:  # param & ret val are 32-bit ints
+    """Convert a 32-bit unsigned integer from network to host byte order.
+"""
+def ntohs(x: int, /) -> int:  # param & ret val are 16-bit ints
+    """Convert a 16-bit unsigned integer from network to host byte order.
+"""
+def htonl(x: int, /) -> int:  # param & ret val are 32-bit ints
+    """Convert a 32-bit unsigned integer from host to network byte order.
+"""
+def htons(x: int, /) -> int:  # param & ret val are 16-bit ints
+    """Convert a 16-bit unsigned integer from host to network byte order.
+"""
+def inet_aton(ip_addr: str, /) -> bytes:  # ret val 4 bytes in length
+    """Convert an IP address in string format (123.45.67.89) to the 32-bit packed binary format used in low-level network functions.
+"""
+def inet_ntoa(packed_ip: ReadableBuffer, /) -> str:
+    """Convert an IP address from 32-bit packed binary format to string format.
+"""
+def inet_pton(address_family: int, ip_string: str, /) -> bytes:
+    """inet_pton(af, ip) -> packed IP address string
+
+Convert an IP address from string format to a packed string suitable
+for use with low-level network functions.
+"""
+def inet_ntop(address_family: int, packed_ip: ReadableBuffer, /) -> str:
+    """inet_ntop(af, packed_ip) -> string formatted IP address
+
+Convert a packed IP address of the given family to string format.
+"""
+def getdefaulttimeout() -> float | None:
+    """getdefaulttimeout() -> timeout
+
+Returns the default timeout in seconds (float) for new socket objects.
+A value of None indicates that new socket objects have no timeout.
+When the socket module is first imported, the default is None.
+"""
 
 # F811: "Redefinition of unused `timeout`"
-def setdefaulttimeout(timeout: float | None, /) -> None: ...  # noqa: F811
+def setdefaulttimeout(timeout: float | None, /) -> None:  # noqa: F811
+    """setdefaulttimeout(timeout)
+
+Set the default timeout in seconds (float) for new socket objects.
+A value of None indicates that new socket objects have no timeout.
+When the socket module is first imported, the default is None.
+"""
 
 if sys.platform != "win32":
-    def sethostname(name: str, /) -> None: ...
+    def sethostname(name: str, /) -> None:
-    def CMSG_LEN(length: int, /) -> int: ...
+        """sethostname(name)
-    def CMSG_SPACE(length: int, /) -> int: ...
-    def socketpair(family: int = ..., type: int = ..., proto: int = 0, /) -> tuple[socket, socket]: ...
 
-def if_nameindex() -> list[tuple[int, str]]: ...
+Sets the hostname to name.
-def if_nametoindex(oname: str, /) -> int: ...
+"""
+    def CMSG_LEN(length: int, /) -> int:
+        """CMSG_LEN(length) -> control message length
+
+Return the total length, without trailing padding, of an ancillary
+data item with associated data of the given length.  This value can
+often be used as the buffer size for recvmsg() to receive a single
+item of ancillary data, but RFC 3542 requires portable applications to
+use CMSG_SPACE() and thus include space for padding, even when the
+item will be the last in the buffer.  Raises OverflowError if length
+is outside the permissible range of values.
+"""
+    def CMSG_SPACE(length: int, /) -> int:
+        """CMSG_SPACE(length) -> buffer size
+
+Return the buffer size needed for recvmsg() to receive an ancillary
+data item with associated data of the given length, along with any
+trailing padding.  The buffer space needed to receive multiple items
+is the sum of the CMSG_SPACE() values for their associated data
+lengths.  Raises OverflowError if length is outside the permissible
+range of values.
+"""
+    def socketpair(family: int = ..., type: int = ..., proto: int = 0, /) -> tuple[socket, socket]:
+        """socketpair([family[, type [, proto]]]) -> (socket object, socket object)
+
+Create a pair of socket objects from the sockets returned by the platform
+socketpair() function.
+The arguments are the same as for socket() except the default family is
+AF_UNIX if defined on the platform; otherwise, the default is AF_INET.
+"""
+
+def if_nameindex() -> list[tuple[int, str]]:
+    """if_nameindex()
+
+Returns a list of network interface information (index, name) tuples.
+"""
+def if_nametoindex(oname: str, /) -> int:
+    """Returns the interface index corresponding to the interface name if_name.
+"""
 
 if sys.version_info >= (3, 14):
-    def if_indextoname(if_index: int, /) -> str: ...
+    def if_indextoname(if_index: int, /) -> str:
+        """Returns the interface name corresponding to the interface index if_index.
+"""
 
 else:
-    def if_indextoname(index: int, /) -> str: ...
+    def if_indextoname(index: int, /) -> str:
+        """if_indextoname(if_index)
+
+Returns the interface name corresponding to the interface index if_index.
+"""
 
 CAPI: CapsuleType

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

@@ -215,10 +215,14 @@ if sys.version_info >= (3, 11):
 
 # Can take or return anything depending on what's in the registry.
 @overload
-def adapt(obj: Any, proto: Any, /) -> Any: ...
+def adapt(obj: Any, proto: Any, /) -> Any:
+    """Adapt given object to given protocol.
+"""
 @overload
 def adapt(obj: Any, proto: Any, alt: _T, /) -> Any | _T: ...
-def complete_statement(statement: str) -> bool: ...
+def complete_statement(statement: str) -> bool:
+    """Checks if a string contains a complete SQL statement.
+"""
 
 if sys.version_info >= (3, 12):
     @overload
@@ -232,7 +236,17 @@ if sys.version_info >= (3, 12):
         uri: bool = False,
         *,
         autocommit: bool = ...,
-    ) -> Connection: ...
+    ) -> Connection:
+        """Open a connection to the SQLite database file 'database'.
+
+You can use ":memory:" to open a database connection to a database that
+resides in RAM instead of on disk.
+
+Note: Passing more than 1 positional argument to _sqlite3.connect() is
+deprecated. Parameters 'timeout', 'detect_types', 'isolation_level',
+'check_same_thread', 'factory', 'cached_statements' and 'uri' will
+become keyword-only parameters in Python 3.15.
+"""
     @overload
     def connect(
         database: StrOrBytesPath,
@@ -270,7 +284,12 @@ else:
         check_same_thread: bool = True,
         cached_statements: int = 128,
         uri: bool = False,
-    ) -> Connection: ...
+    ) -> Connection:
+        """Opens a connection to the SQLite database file database.
+
+You can use ":memory:" to open a database connection to a database that resides
+in RAM instead of on disk.
+"""
     @overload
     def connect(
         database: StrOrBytesPath,
@@ -295,19 +314,40 @@ else:
         uri: bool = False,
     ) -> _ConnectionT: ...
 
-def enable_callback_tracebacks(enable: bool, /) -> None: ...
+def enable_callback_tracebacks(enable: bool, /) -> None:
+    """Enable or disable callback functions throwing errors to stderr.
+"""
 
 if sys.version_info < (3, 12):
     # takes a pos-or-keyword argument because there is a C wrapper
-    def enable_shared_cache(do_enable: int) -> None: ...
+    def enable_shared_cache(do_enable: int) -> None:
+        """Enable or disable shared cache mode for the calling thread.
+
+This method is deprecated and will be removed in Python 3.12.
+Shared cache is strongly discouraged by the SQLite 3 documentation.
+If shared cache must be used, open the database in URI mode using
+the cache=shared query parameter.
+"""
 
 if sys.version_info >= (3, 10):
-    def register_adapter(type: type[_T], adapter: _Adapter[_T], /) -> None: ...
+    def register_adapter(type: type[_T], adapter: _Adapter[_T], /) -> None:
-    def register_converter(typename: str, converter: _Converter, /) -> None: ...
+        """Register a function to adapt Python objects to SQLite values.
+"""
+    def register_converter(typename: str, converter: _Converter, /) -> None:
+        """Register a function to convert SQLite values to Python objects.
+"""
 
 else:
-    def register_adapter(type: type[_T], caster: _Adapter[_T], /) -> None: ...
+    def register_adapter(type: type[_T], caster: _Adapter[_T], /) -> None:
-    def register_converter(name: str, converter: _Converter, /) -> None: ...
+        """register_adapter(type, callable)
+
+Registers an adapter with sqlite3's adapter registry.
+"""
+    def register_converter(name: str, converter: _Converter, /) -> None:
+        """register_converter(typename, callable)
+
+Registers a converter with sqlite3.
+"""
 
 if sys.version_info < (3, 10):
     OptimizedUnicode = str

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

@@ -1,3 +1,6 @@
+"""Implementation module for SSL socket operations.  See the socket module
+for documentation.
+"""
 import sys
 from _typeshed import ReadableBuffer, StrOrBytesPath
 from collections.abc import Callable
@@ -47,26 +50,54 @@ class _CertInfo(TypedDict):
     caIssuers: NotRequired[tuple[str, ...] | None]
     crlDistributionPoints: NotRequired[tuple[str, ...] | None]
 
-def RAND_add(string: str | ReadableBuffer, entropy: float, /) -> None: ...
+def RAND_add(string: str | ReadableBuffer, entropy: float, /) -> None:
-def RAND_bytes(n: int, /) -> bytes: ...
+    """Mix string into the OpenSSL PRNG state.
+
+entropy (a float) is a lower bound on the entropy contained in
+string.  See RFC 4086.
+"""
+def RAND_bytes(n: int, /) -> bytes:
+    """Generate n cryptographically strong pseudo-random bytes.
+"""
 
 if sys.version_info < (3, 12):
     @deprecated("Deprecated since Python 3.6; removed in Python 3.12. Use `ssl.RAND_bytes()` instead.")
-    def RAND_pseudo_bytes(n: int, /) -> tuple[bytes, bool]: ...
+    def RAND_pseudo_bytes(n: int, /) -> tuple[bytes, bool]:
+        """Generate n pseudo-random bytes.
+
+Return a pair (bytes, is_cryptographic).  is_cryptographic is True
+if the bytes generated are cryptographically strong.
+"""
 
 if sys.version_info < (3, 10):
     def RAND_egd(path: str) -> None: ...
 
-def RAND_status() -> bool: ...
+def RAND_status() -> bool:
-def get_default_verify_paths() -> tuple[str, str, str, str]: ...
+    """Returns True if the OpenSSL PRNG has been seeded with enough data and False if not.
+
+It is necessary to seed the PRNG with RAND_add() on some platforms before
+using the ssl() function.
+"""
+def get_default_verify_paths() -> tuple[str, str, str, str]:
+    """Return search paths and environment vars that are used by SSLContext's set_default_verify_paths() to load default CAs.
+
+The values are 'cert_file_env', 'cert_file', 'cert_dir_env', 'cert_dir'.
+"""
 
 if sys.platform == "win32":
     _EnumRetType: TypeAlias = list[tuple[bytes, str, set[str] | bool]]
     def enum_certificates(store_name: str) -> _EnumRetType: ...
     def enum_crls(store_name: str) -> _EnumRetType: ...
 
-def txt2obj(txt: str, name: bool = False) -> tuple[int, str, str, str]: ...
+def txt2obj(txt: str, name: bool = False) -> tuple[int, str, str, str]:
-def nid2obj(nid: int, /) -> tuple[int, str, str, str]: ...
+    """Lookup NID, short name, long name and OID of an ASN1_OBJECT.
+
+By default objects are looked up by OID. With name=True short and
+long name are also matched.
+"""
+def nid2obj(nid: int, /) -> tuple[int, str, str, str]:
+    """Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.
+"""
 @disjoint_base
 class _SSLContext:
     check_hostname: bool
@@ -83,9 +114,25 @@ class _SSLContext:
     verify_flags: int
     verify_mode: int
     def __new__(cls, protocol: int, /) -> Self: ...
-    def cert_store_stats(self) -> dict[str, int]: ...
+    def cert_store_stats(self) -> dict[str, int]:
+        """Returns quantities of loaded X.509 certificates.
+
+X.509 certificates with a CA extension and certificate revocation lists
+inside the context's cert store.
+
+NOTE: Certificates in a capath directory aren't loaded unless they have
+been used at least once.
+"""
     @overload
-    def get_ca_certs(self, binary_form: Literal[False] = False) -> list[_PeerCertRetDictType]: ...
+    def get_ca_certs(self, binary_form: Literal[False] = False) -> list[_PeerCertRetDictType]:
+        """Returns a list of dicts with information of loaded CA certs.
+
+If the optional argument is True, returns a DER-encoded copy of the CA
+certificate.
+
+NOTE: Certificates in a capath directory aren't loaded unless they have
+been used at least once.
+"""
     @overload
     def get_ca_certs(self, binary_form: Literal[True]) -> list[bytes]: ...
     @overload
@@ -116,23 +163,48 @@ class MemoryBIO:
     eof: bool
     pending: int
     def __new__(self) -> Self: ...
-    def read(self, size: int = -1, /) -> bytes: ...
+    def read(self, size: int = -1, /) -> bytes:
-    def write(self, b: ReadableBuffer, /) -> int: ...
+        """Read up to size bytes from the memory BIO.
-    def write_eof(self) -> None: ...
+
+If size is not specified, read the entire buffer.
+If the return value is an empty bytes instance, this means either
+EOF or that no data is available. Use the "eof" property to
+distinguish between the two.
+"""
+    def write(self, b: ReadableBuffer, /) -> int:
+        """Writes the bytes b into the memory BIO.
+
+Returns the number of bytes written.
+"""
+    def write_eof(self) -> None:
+        """Write an EOF marker to the memory BIO.
+
+When all data has been read, the "eof" property will be True.
+"""
 
 @final
 class SSLSession:
     __hash__: ClassVar[None]  # type: ignore[assignment]
     @property
-    def has_ticket(self) -> bool: ...
+    def has_ticket(self) -> bool:
+        """Does the session contain a ticket?
+"""
     @property
-    def id(self) -> bytes: ...
+    def id(self) -> bytes:
+        """Session ID.
+"""
     @property
-    def ticket_lifetime_hint(self) -> int: ...
+    def ticket_lifetime_hint(self) -> int:
+        """Ticket life time hint.
+"""
     @property
-    def time(self) -> int: ...
+    def time(self) -> int:
+        """Session creation time (seconds since epoch).
+"""
     @property
-    def timeout(self) -> int: ...
+    def timeout(self) -> int:
+        """Session timeout (delta in seconds).
+"""
 
 # _ssl.Certificate is weird: it can't be instantiated or subclassed.
 # Instances can only be created via methods of the private _ssl._SSLSocket class,

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

@@ -1,3 +1,73 @@
+"""S_IFMT_: file type bits
+S_IFDIR: directory
+S_IFCHR: character device
+S_IFBLK: block device
+S_IFREG: regular file
+S_IFIFO: fifo (named pipe)
+S_IFLNK: symbolic link
+S_IFSOCK: socket file
+S_IFDOOR: door
+S_IFPORT: event port
+S_IFWHT: whiteout
+
+S_ISUID: set UID bit
+S_ISGID: set GID bit
+S_ENFMT: file locking enforcement
+S_ISVTX: sticky bit
+S_IREAD: Unix V7 synonym for S_IRUSR
+S_IWRITE: Unix V7 synonym for S_IWUSR
+S_IEXEC: Unix V7 synonym for S_IXUSR
+S_IRWXU: mask for owner permissions
+S_IRUSR: read by owner
+S_IWUSR: write by owner
+S_IXUSR: execute by owner
+S_IRWXG: mask for group permissions
+S_IRGRP: read by group
+S_IWGRP: write by group
+S_IXGRP: execute by group
+S_IRWXO: mask for others (not in group) permissions
+S_IROTH: read by others
+S_IWOTH: write by others
+S_IXOTH: execute by others
+
+UF_SETTABLE: mask of owner changeable flags
+UF_NODUMP: do not dump file
+UF_IMMUTABLE: file may not be changed
+UF_APPEND: file may only be appended to
+UF_OPAQUE: directory is opaque when viewed through a union stack
+UF_NOUNLINK: file may not be renamed or deleted
+UF_COMPRESSED: macOS: file is hfs-compressed
+UF_TRACKED: used for dealing with document IDs
+UF_DATAVAULT: entitlement required for reading and writing
+UF_HIDDEN: macOS: file should not be displayed
+SF_SETTABLE: mask of super user changeable flags
+SF_ARCHIVED: file may be archived
+SF_IMMUTABLE: file may not be changed
+SF_APPEND: file may only be appended to
+SF_RESTRICTED: entitlement required for writing
+SF_NOUNLINK: file may not be renamed or deleted
+SF_SNAPSHOT: file is a snapshot file
+SF_FIRMLINK: file is a firmlink
+SF_DATALESS: file is a dataless object
+
+On macOS:
+SF_SUPPORTED: mask of super user supported flags
+SF_SYNTHETIC: mask of read-only synthetic flags
+
+ST_MODE
+ST_INO
+ST_DEV
+ST_NLINK
+ST_UID
+ST_GID
+ST_SIZE
+ST_ATIME
+ST_MTIME
+ST_CTIME
+
+FILE_ATTRIBUTE_*: Windows file attribute constants
+                   (only present on Windows)
+"""
 import sys
 from typing import Final
 
@@ -64,19 +134,65 @@ UF_NODUMP: Final = 0x00000001
 UF_NOUNLINK: Final = 0x00000010
 UF_OPAQUE: Final = 0x00000008
 
-def S_IMODE(mode: int, /) -> int: ...
+def S_IMODE(mode: int, /) -> int:
-def S_IFMT(mode: int, /) -> int: ...
+    """Return the portion of the file's mode that can be set by os.chmod().
-def S_ISBLK(mode: int, /) -> bool: ...
+"""
-def S_ISCHR(mode: int, /) -> bool: ...
+def S_IFMT(mode: int, /) -> int:
-def S_ISDIR(mode: int, /) -> bool: ...
+    """Return the portion of the file's mode that describes the file type.
-def S_ISDOOR(mode: int, /) -> bool: ...
+"""
-def S_ISFIFO(mode: int, /) -> bool: ...
+def S_ISBLK(mode: int, /) -> bool:
-def S_ISLNK(mode: int, /) -> bool: ...
+    """S_ISBLK(mode) -> bool
-def S_ISPORT(mode: int, /) -> bool: ...
+
-def S_ISREG(mode: int, /) -> bool: ...
+Return True if mode is from a block special device file.
-def S_ISSOCK(mode: int, /) -> bool: ...
+"""
-def S_ISWHT(mode: int, /) -> bool: ...
+def S_ISCHR(mode: int, /) -> bool:
-def filemode(mode: int, /) -> str: ...
+    """S_ISCHR(mode) -> bool
+
+Return True if mode is from a character special device file.
+"""
+def S_ISDIR(mode: int, /) -> bool:
+    """S_ISDIR(mode) -> bool
+
+Return True if mode is from a directory.
+"""
+def S_ISDOOR(mode: int, /) -> bool:
+    """S_ISDOOR(mode) -> bool
+
+Return True if mode is from a door.
+"""
+def S_ISFIFO(mode: int, /) -> bool:
+    """S_ISFIFO(mode) -> bool
+
+Return True if mode is from a FIFO (named pipe).
+"""
+def S_ISLNK(mode: int, /) -> bool:
+    """S_ISLNK(mode) -> bool
+
+Return True if mode is from a symbolic link.
+"""
+def S_ISPORT(mode: int, /) -> bool:
+    """S_ISPORT(mode) -> bool
+
+Return True if mode is from an event port.
+"""
+def S_ISREG(mode: int, /) -> bool:
+    """S_ISREG(mode) -> bool
+
+Return True if mode is from a regular file.
+"""
+def S_ISSOCK(mode: int, /) -> bool:
+    """S_ISSOCK(mode) -> bool
+
+Return True if mode is from a socket.
+"""
+def S_ISWHT(mode: int, /) -> bool:
+    """S_ISWHT(mode) -> bool
+
+Return True if mode is from a whiteout.
+"""
+def filemode(mode: int, /) -> str:
+    """Convert a file's mode to a string of the form '-rwxrwxrwx'
+"""
 
 if sys.platform == "win32":
     IO_REPARSE_TAG_SYMLINK: Final = 0xA000000C

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

@@ -1,23 +1,128 @@
+"""Functions to convert between Python values and C structs.
+Python bytes objects are used to hold the data representing the C struct
+and also as format strings (explained below) to describe the layout of data
+in the C struct.
+
+The optional first format char indicates byte order, size and alignment:
+  @: native order, size & alignment (default)
+  =: native order, std. size & alignment
+  <: little-endian, std. size & alignment
+  >: big-endian, std. size & alignment
+  !: same as >
+
+The remaining chars indicate types of args and must match exactly;
+these can be preceded by a decimal repeat count:
+  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
+  ?: _Bool (requires C99; if not available, char is used instead)
+  h:short; H:unsigned short; i:int; I:unsigned int;
+  l:long; L:unsigned long; f:float; d:double; e:half-float.
+Special cases (preceding decimal count indicates length):
+  s:string (array of char); p: pascal string (with count byte).
+Special cases (only available in native format):
+  n:ssize_t; N:size_t;
+  P:an integer type that is wide enough to hold a pointer.
+Special case (not in native mode unless 'long long' in platform C):
+  q:long long; Q:unsigned long long
+Whitespace between formats is ignored.
+
+The variable struct.error is an exception raised on errors.
+"""
 from _typeshed import ReadableBuffer, WriteableBuffer
 from collections.abc import Iterator
 from typing import Any
 from typing_extensions import disjoint_base
 
-def pack(fmt: str | bytes, /, *v: Any) -> bytes: ...
+def pack(fmt: str | bytes, /, *v: Any) -> bytes:
-def pack_into(fmt: str | bytes, buffer: WriteableBuffer, offset: int, /, *v: Any) -> None: ...
+    """pack(format, v1, v2, ...) -> bytes
-def unpack(format: str | bytes, buffer: ReadableBuffer, /) -> tuple[Any, ...]: ...
+
-def unpack_from(format: str | bytes, /, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]: ...
+Return a bytes object containing the values v1, v2, ... packed according
-def iter_unpack(format: str | bytes, buffer: ReadableBuffer, /) -> Iterator[tuple[Any, ...]]: ...
+to the format string.  See help(struct) for more on format strings.
-def calcsize(format: str | bytes, /) -> int: ...
+"""
+def pack_into(fmt: str | bytes, buffer: WriteableBuffer, offset: int, /, *v: Any) -> None:
+    """pack_into(format, buffer, offset, v1, v2, ...)
+
+Pack the values v1, v2, ... according to the format string and write
+the packed bytes into the writable buffer buf starting at offset.  Note
+that the offset is a required argument.  See help(struct) for more
+on format strings.
+"""
+def unpack(format: str | bytes, buffer: ReadableBuffer, /) -> tuple[Any, ...]:
+    """Return a tuple containing values unpacked according to the format string.
+
+The buffer's size in bytes must be calcsize(format).
+
+See help(struct) for more on format strings.
+"""
+def unpack_from(format: str | bytes, /, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]:
+    """Return a tuple containing values unpacked according to the format string.
+
+The buffer's size, minus offset, must be at least calcsize(format).
+
+See help(struct) for more on format strings.
+"""
+def iter_unpack(format: str | bytes, buffer: ReadableBuffer, /) -> Iterator[tuple[Any, ...]]:
+    """Return an iterator yielding tuples unpacked from the given bytes.
+
+The bytes are unpacked according to the format string, like
+a repeated invocation of unpack_from().
+
+Requires that the bytes length be a multiple of the format struct size.
+"""
+def calcsize(format: str | bytes, /) -> int:
+    """Return size in bytes of the struct described by the format string.
+"""
 @disjoint_base
 class Struct:
+    """Struct(fmt) --> compiled struct object
+
+"""
     @property
-    def format(self) -> str: ...
+    def format(self) -> str:
+        """struct format string
+"""
     @property
-    def size(self) -> int: ...
+    def size(self) -> int:
+        """struct size in bytes
+"""
     def __init__(self, format: str | bytes) -> None: ...
-    def pack(self, *v: Any) -> bytes: ...
+    def pack(self, *v: Any) -> bytes:
-    def pack_into(self, buffer: WriteableBuffer, offset: int, *v: Any) -> None: ...
+        """S.pack(v1, v2, ...) -> bytes
-    def unpack(self, buffer: ReadableBuffer, /) -> tuple[Any, ...]: ...
+
-    def unpack_from(self, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]: ...
+Return a bytes object containing values v1, v2, ... packed according
-    def iter_unpack(self, buffer: ReadableBuffer, /) -> Iterator[tuple[Any, ...]]: ...
+to the format string S.format.  See help(struct) for more on format
+strings.
+"""
+    def pack_into(self, buffer: WriteableBuffer, offset: int, *v: Any) -> None:
+        """S.pack_into(buffer, offset, v1, v2, ...)
+
+Pack the values v1, v2, ... according to the format string S.format
+and write the packed bytes into the writable buffer buf starting at
+offset.  Note that the offset is a required argument.  See
+help(struct) for more on format strings.
+"""
+    def unpack(self, buffer: ReadableBuffer, /) -> tuple[Any, ...]:
+        """Return a tuple containing unpacked values.
+
+Unpack according to the format string Struct.format. The buffer's size
+in bytes must be Struct.size.
+
+See help(struct) for more on format strings.
+"""
+    def unpack_from(self, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]:
+        """Return a tuple containing unpacked values.
+
+Values are unpacked according to the format string Struct.format.
+
+The buffer's size in bytes, starting at position offset, must be
+at least Struct.size.
+
+See help(struct) for more on format strings.
+"""
+    def iter_unpack(self, buffer: ReadableBuffer, /) -> Iterator[tuple[Any, ...]]:
+        """Return an iterator yielding tuples.
+
+Tuples are unpacked from the given bytes source, like a repeated
+invocation of unpack_from().
+
+Requires that the bytes length be a multiple of the struct size.
+"""

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

@@ -1,3 +1,6 @@
+"""This module provides primitive operations to write multi-threaded programs.
+The 'threading' module provides a more convenient interface.
+"""
 import signal
 import sys
 from _typeshed import structseq
@@ -11,15 +14,51 @@ _Ts = TypeVarTuple("_Ts")
 
 error = RuntimeError
 
-def _count() -> int: ...
+def _count() -> int:
+    """Return the number of currently running Python threads, excluding
+the main thread. The returned number comprises all threads created
+through `start_new_thread()` as well as `threading.Thread`, and not
+yet finished.
+
+This function is meant for internal and specialized purposes only.
+In most applications `threading.enumerate()` should be used instead.
+"""
 @final
 class RLock:
-    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool:
-    def release(self) -> None: ...
+        """Lock the lock.  `blocking` indicates whether we should wait
+for the lock to be available or not.  If `blocking` is False
+and another thread holds the lock, the method will return False
+immediately.  If `blocking` is True and another thread holds
+the lock, the method will wait for the lock to be released,
+take it and then return True.
+(note: the blocking operation is interruptible.)
+
+In all other cases, the method will return True immediately.
+Precisely, if the current thread already holds the lock, its
+internal counter is simply incremented. If nobody holds the lock,
+the lock is taken and its internal counter initialized to 1.
+"""
+    def release(self) -> None:
+        """Release the lock, allowing another thread that is blocked waiting for
+the lock to acquire the lock.  The lock must be in the locked state,
+and must be locked by the same thread that unlocks it; otherwise a
+`RuntimeError` is raised.
+
+Do note that if the lock was acquire()d several times in a row by the
+current thread, release() needs to be called as many times for the lock
+to be available for other threads.
+"""
     __enter__ = acquire
-    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None:
+        """Release the lock.
+"""
     if sys.version_info >= (3, 14):
-        def locked(self) -> bool: ...
+        def locked(self) -> bool:
+            """locked()
+
+Return a boolean indicating whether this object is locked right now.
+"""
 
 if sys.version_info >= (3, 13):
     @final
@@ -32,86 +71,283 @@ if sys.version_info >= (3, 13):
 
     def start_joinable_thread(
         function: Callable[[], object], handle: _ThreadHandle | None = None, daemon: bool = True
-    ) -> _ThreadHandle: ...
+    ) -> _ThreadHandle:
+        """*For internal use only*: start a new thread.
+
+Like start_new_thread(), this starts a new thread calling the given function.
+Unlike start_new_thread(), this returns a handle object with methods to join
+or detach the given thread.
+This function is not for third-party code, please use the
+`threading` module instead. During finalization the runtime will not wait for
+the thread to exit if daemon is True. If handle is provided it must be a
+newly created thread._ThreadHandle instance.
+"""
     @final
     class lock:
-        def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        """A lock object is a synchronization primitive.  To create a lock,
-        def release(self) -> None: ...
+call threading.Lock().  Methods are:
-        def locked(self) -> bool: ...
+
-        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+acquire() -- lock the lock, possibly blocking until it can be obtained
-        def release_lock(self) -> None: ...
+release() -- unlock of the lock
-        def locked_lock(self) -> bool: ...
+locked() -- test whether the lock is currently locked
-        def __enter__(self) -> bool: ...
+
+A lock is not owned by the thread that locked it; another thread may
+unlock it.  A thread attempting to lock a lock that it has already locked
+will block until another thread unlocks it.  Deadlocks may ensue.
+"""
+        def acquire(self, blocking: bool = True, timeout: float = -1) -> bool:
+            """Lock the lock.  Without argument, this blocks if the lock is already
+locked (even by the same thread), waiting for another thread to release
+the lock, and return True once the lock is acquired.
+With an argument, this will only block if the argument is true,
+and the return value reflects whether the lock is acquired.
+The blocking operation is interruptible.
+"""
+        def release(self) -> None:
+            """Release the lock, allowing another thread that is blocked waiting for
+the lock to acquire the lock.  The lock must be in the locked state,
+but it needn't be locked by the same thread that unlocks it.
+"""
+        def locked(self) -> bool:
+            """Return whether the lock is in the locked state.
+"""
+        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool:
+            """An obsolete synonym of acquire().
+"""
+        def release_lock(self) -> None:
+            """An obsolete synonym of release().
+"""
+        def locked_lock(self) -> bool:
+            """An obsolete synonym of locked().
+"""
+        def __enter__(self) -> bool:
+            """Lock the lock.
+"""
         def __exit__(
             self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> None: ...
+        ) -> None:
+            """Release the lock.
+"""
 
     LockType = lock
 else:
     @final
     class LockType:
-        def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        """A lock object is a synchronization primitive.  To create a lock,
-        def release(self) -> None: ...
+call threading.Lock().  Methods are:
-        def locked(self) -> bool: ...
+
-        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+acquire() -- lock the lock, possibly blocking until it can be obtained
-        def release_lock(self) -> None: ...
+release() -- unlock of the lock
-        def locked_lock(self) -> bool: ...
+locked() -- test whether the lock is currently locked
-        def __enter__(self) -> bool: ...
+
+A lock is not owned by the thread that locked it; another thread may
+unlock it.  A thread attempting to lock a lock that it has already locked
+will block until another thread unlocks it.  Deadlocks may ensue.
+"""
+        def acquire(self, blocking: bool = True, timeout: float = -1) -> bool:
+            """acquire(blocking=True, timeout=-1) -> bool
+(acquire_lock() is an obsolete synonym)
+
+Lock the lock.  Without argument, this blocks if the lock is already
+locked (even by the same thread), waiting for another thread to release
+the lock, and return True once the lock is acquired.
+With an argument, this will only block if the argument is true,
+and the return value reflects whether the lock is acquired.
+The blocking operation is interruptible.
+"""
+        def release(self) -> None:
+            """release()
+(release_lock() is an obsolete synonym)
+
+Release the lock, allowing another thread that is blocked waiting for
+the lock to acquire the lock.  The lock must be in the locked state,
+but it needn't be locked by the same thread that unlocks it.
+"""
+        def locked(self) -> bool:
+            """locked() -> bool
+(locked_lock() is an obsolete synonym)
+
+Return whether the lock is in the locked state.
+"""
+        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool:
+            """acquire(blocking=True, timeout=-1) -> bool
+(acquire_lock() is an obsolete synonym)
+
+Lock the lock.  Without argument, this blocks if the lock is already
+locked (even by the same thread), waiting for another thread to release
+the lock, and return True once the lock is acquired.
+With an argument, this will only block if the argument is true,
+and the return value reflects whether the lock is acquired.
+The blocking operation is interruptible.
+"""
+        def release_lock(self) -> None:
+            """release()
+(release_lock() is an obsolete synonym)
+
+Release the lock, allowing another thread that is blocked waiting for
+the lock to acquire the lock.  The lock must be in the locked state,
+but it needn't be locked by the same thread that unlocks it.
+"""
+        def locked_lock(self) -> bool:
+            """locked() -> bool
+(locked_lock() is an obsolete synonym)
+
+Return whether the lock is in the locked state.
+"""
+        def __enter__(self) -> bool:
+            """acquire(blocking=True, timeout=-1) -> bool
+(acquire_lock() is an obsolete synonym)
+
+Lock the lock.  Without argument, this blocks if the lock is already
+locked (even by the same thread), waiting for another thread to release
+the lock, and return True once the lock is acquired.
+With an argument, this will only block if the argument is true,
+and the return value reflects whether the lock is acquired.
+The blocking operation is interruptible.
+"""
         def __exit__(
             self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> None: ...
+        ) -> None:
+            """release()
+(release_lock() is an obsolete synonym)
+
+Release the lock, allowing another thread that is blocked waiting for
+the lock to acquire the lock.  The lock must be in the locked state,
+but it needn't be locked by the same thread that unlocks it.
+"""
 
 @overload
-def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int: ...
+def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int:
+    """Start a new thread and return its identifier.
+
+The thread will call the function with positional arguments from the
+tuple args and keyword arguments taken from the optional dictionary
+kwargs.  The thread exits when the function returns; the return value
+is ignored.  The thread will also exit when the function raises an
+unhandled exception; a stack trace will be printed unless the exception
+is SystemExit.
+"""
 @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: ...
+def start_new(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int:
+    """An obsolete synonym of start_new_thread().
+"""
 @overload
 def start_new(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
 
 if sys.version_info >= (3, 10):
-    def interrupt_main(signum: signal.Signals = signal.SIGINT, /) -> None: ...
+    def interrupt_main(signum: signal.Signals = signal.SIGINT, /) -> None:
+        """Simulate the arrival of the given signal in the main thread,
+where the corresponding signal handler will be executed.
+If *signum* is omitted, SIGINT is assumed.
+A subthread can use this function to interrupt the main thread.
+
+Note: the default signal handler for SIGINT raises ``KeyboardInterrupt``.
+"""
 
 else:
-    def interrupt_main() -> None: ...
+    def interrupt_main() -> None:
+        """interrupt_main()
 
-def exit() -> NoReturn: ...
+Raise a KeyboardInterrupt in the main thread.
-def exit_thread() -> NoReturn: ...  # Obsolete synonym for exit()
+A subthread can use this function to interrupt the main thread.
-def allocate_lock() -> LockType: ...
+"""
-def allocate() -> LockType: ...  # Obsolete synonym for allocate_lock()
+
-def get_ident() -> int: ...
+def exit() -> NoReturn:
-def stack_size(size: int = 0, /) -> int: ...
+    """This is synonymous to ``raise SystemExit''.  It will cause the current
+thread to exit silently unless the exception is caught.
+"""
+def exit_thread() -> NoReturn:  # Obsolete synonym for exit()
+    """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()
+    """An obsolete synonym of allocate_lock().
+"""
+def get_ident() -> int:
+    """Return a non-zero integer that uniquely identifies the current thread
+amongst other threads that exist simultaneously.
+This may be used to identify per-thread resources.
+Even though on some platforms threads identities may appear to be
+allocated consecutive numbers starting at 1, this behavior should not
+be relied upon, and the number should be seen purely as a magic cookie.
+A thread's identity may be reused for another thread after it exits.
+"""
+def stack_size(size: int = 0, /) -> int:
+    """Return the thread stack size used when creating new threads.  The
+optional size argument specifies the stack size (in bytes) to be used
+for subsequently created threads, and must be 0 (use platform or
+configured default) or a positive integer value of at least 32,768 (32k).
+If changing the thread stack size is unsupported, a ThreadError
+exception is raised.  If the specified size is invalid, a ValueError
+exception is raised, and the stack size is unmodified.  32k bytes
+ currently the minimum supported stack size value to guarantee
+sufficient stack space for the interpreter itself.
+
+Note that some platforms may have particular restrictions on values for
+the stack size, such as requiring a minimum stack size larger than 32 KiB or
+requiring allocation in multiples of the system memory page size
+- platform documentation should be referred to for more information
+(4 KiB pages are common; using multiples of 4096 for the stack size is
+the suggested approach in the absence of more specific information).
+"""
 
 TIMEOUT_MAX: Final[float]
 
-def get_native_id() -> int: ...  # only available on some platforms
+def get_native_id() -> int:  # only available on some platforms
+    """Return a non-negative integer identifying the thread as reported
+by the OS (kernel). This may be used to uniquely identify a
+particular thread within a system.
+"""
 @final
 class _ExceptHookArgs(structseq[Any], tuple[type[BaseException], BaseException | None, TracebackType | None, Thread | None]):
+    """ExceptHookArgs
+
+Type used to pass arguments to threading.excepthook.
+"""
     if sys.version_info >= (3, 10):
         __match_args__: Final = ("exc_type", "exc_value", "exc_traceback", "thread")
 
     @property
-    def exc_type(self) -> type[BaseException]: ...
+    def exc_type(self) -> type[BaseException]:
+        """Exception type
+"""
     @property
-    def exc_value(self) -> BaseException | None: ...
+    def exc_value(self) -> BaseException | None:
+        """Exception value
+"""
     @property
-    def exc_traceback(self) -> TracebackType | None: ...
+    def exc_traceback(self) -> TracebackType | None:
+        """Exception traceback
+"""
     @property
-    def thread(self) -> Thread | None: ...
+    def thread(self) -> Thread | None:
+        """Thread
+"""
 
 _excepthook: Callable[[_ExceptHookArgs], Any]
 
 if sys.version_info >= (3, 12):
-    def daemon_threads_allowed() -> bool: ...
+    def daemon_threads_allowed() -> bool:
+        """Return True if daemon threads are allowed in the current interpreter,
+and False otherwise.
+"""
 
 if sys.version_info >= (3, 14):
-    def set_name(name: str) -> None: ...
+    def set_name(name: str) -> None:
+        """Set the name of the current thread.
+"""
 
 @disjoint_base
 class _local:
+    """Thread-local data
+"""
     def __getattribute__(self, name: str, /) -> Any: ...
     def __setattr__(self, name: str, value: Any, /) -> None: ...
     def __delattr__(self, name: str, /) -> None: ...

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

@@ -1,3 +1,10 @@
+"""Thread-local objects.
+
+(Note that this module provides a Python version of the threading.local
+ class.  Depending on the version of Python you're using, there may be a
+ faster one available.  You should always import the `local` class from
+ `threading`.)
+"""
 from threading import RLock
 from typing import Any
 from typing_extensions import Self, TypeAlias
@@ -7,14 +14,21 @@ __all__ = ["local"]
 _LocalDict: TypeAlias = dict[Any, Any]
 
 class _localimpl:
+    """A class managing thread-local dicts
+"""
     __slots__ = ("key", "dicts", "localargs", "locallock", "__weakref__")
     key: str
     dicts: dict[int, tuple[ReferenceType[Any], _LocalDict]]
     # Keep localargs in sync with the *args, **kwargs annotation on local.__new__
     localargs: tuple[list[Any], dict[str, Any]]
     locallock: RLock
-    def get_dict(self) -> _LocalDict: ...
+    def get_dict(self) -> _LocalDict:
-    def create_dict(self) -> _LocalDict: ...
+        """Return the dict for the current thread. Raises KeyError if none
+defined.
+"""
+    def create_dict(self) -> _LocalDict:
+        """Create a new dict for the current thread, and return it.
+"""
 
 class local:
     __slots__ = ("_local__impl", "__dict__")

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

@@ -19,9 +19,13 @@ from typing_extensions import TypeAlias, deprecated
 @final
 class Tcl_Obj:
     @property
-    def string(self) -> str: ...
+    def string(self) -> str:
+        """the string representation of this object, either as str or bytes
+"""
     @property
-    def typename(self) -> str: ...
+    def typename(self) -> str:
+        """name of the Tcl type
+"""
     __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, value, /): ...
     def __ge__(self, value, /): ...
@@ -92,8 +96,12 @@ class TkappType:
     def wantobjects(self, *args, **kwargs): ...
     def willdispatch(self) -> None: ...
     if sys.version_info >= (3, 12):
-        def gettrace(self, /) -> _TkinterTraceFunc | None: ...
+        def gettrace(self, /) -> _TkinterTraceFunc | None:
-        def settrace(self, func: _TkinterTraceFunc | None, /) -> None: ...
+            """Get the tracing function.
+"""
+        def settrace(self, func: _TkinterTraceFunc | None, /) -> None:
+            """Set the tracing function.
+"""
 
 # These should be kept in sync with tkinter.tix constants, except ALL_EVENTS which doesn't match TCL_ALL_EVENTS
 ALL_EVENTS: Final = -3
@@ -125,7 +133,16 @@ if sys.version_info >= (3, 13):
         sync: bool = False,
         use: str | None = None,
         /,
-    ): ...
+    ):
+        """
+
+  wantTk
+    if false, then Tk_Init() doesn't get called
+  sync
+    if true, then pass -sync to wish
+  use
+    if not None, then pass -use to wish
+"""
 
 else:
     def create(
@@ -138,7 +155,22 @@ else:
         sync: bool = False,
         use: str | None = None,
         /,
-    ): ...
+    ):
+        """
 
-def getbusywaitinterval() -> int: ...
+  wantTk
-def setbusywaitinterval(new_val: int, /) -> None: ...
+    if false, then Tk_Init() doesn't get called
+  sync
+    if true, then pass -sync to wish
+  use
+    if not None, then pass -use to wish
+"""
+
+def getbusywaitinterval() -> int:
+    """Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.
+"""
+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/_tracemalloc.pyi

@@ -1,13 +1,58 @@
+"""Debug module to trace memory blocks allocated by Python.
+"""
 from collections.abc import Sequence
 from tracemalloc import _FrameTuple, _TraceTuple
 
-def _get_object_traceback(obj: object, /) -> Sequence[_FrameTuple] | None: ...
+def _get_object_traceback(obj: object, /) -> Sequence[_FrameTuple] | None:
-def _get_traces() -> Sequence[_TraceTuple]: ...
+    """Get the traceback where the Python object obj was allocated.
-def clear_traces() -> None: ...
+
-def get_traceback_limit() -> int: ...
+Return a tuple of (filename: str, lineno: int) tuples.
-def get_traced_memory() -> tuple[int, int]: ...
+Return None if the tracemalloc module is disabled or did not
-def get_tracemalloc_memory() -> int: ...
+trace the allocation of the object.
-def is_tracing() -> bool: ...
+"""
-def reset_peak() -> None: ...
+def _get_traces() -> Sequence[_TraceTuple]:
-def start(nframe: int = 1, /) -> None: ...
+    """Get traces of all memory blocks allocated by Python.
-def stop() -> None: ...
+
+Return a list of (size: int, traceback: tuple) tuples.
+traceback is a tuple of (filename: str, lineno: int) tuples.
+
+Return an empty list if the tracemalloc module is disabled.
+"""
+def clear_traces() -> None:
+    """Clear traces of memory blocks allocated by Python.
+"""
+def get_traceback_limit() -> int:
+    """Get the maximum number of frames stored in the traceback of a trace.
+
+By default, a trace of an allocated memory block only stores
+the most recent frame: the limit is 1.
+"""
+def get_traced_memory() -> tuple[int, int]:
+    """Get the current size and peak size of memory blocks traced by tracemalloc.
+
+Returns a tuple: (current: int, peak: int).
+"""
+def get_tracemalloc_memory() -> int:
+    """Get the memory usage in bytes of the tracemalloc module.
+
+This memory is used internally to trace memory allocations.
+"""
+def is_tracing() -> bool:
+    """Return True if the tracemalloc module is tracing Python memory allocations.
+"""
+def reset_peak() -> None:
+    """Set the peak size of memory blocks traced by tracemalloc to the current size.
+
+Do nothing if the tracemalloc module is not tracing memory allocations.
+"""
+def start(nframe: int = 1, /) -> None:
+    """Start tracing Python memory allocations.
+
+Also set the maximum number of frames stored in the traceback of a
+trace to nframe.
+"""
+def stop() -> None:
+    """Stop tracing Python memory allocations.
+
+Also clear traces of memory blocks allocated by Python.
+"""

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

@@ -1,3 +1,6 @@
+"""_warnings provides basic warning filtering support.
+It is a helper module to speed up interpreter start-up.
+"""
 import sys
 from typing import Any, overload
 
@@ -14,7 +17,22 @@ if sys.version_info >= (3, 12):
         source: Any | None = None,
         *,
         skip_file_prefixes: tuple[str, ...] = (),
-    ) -> None: ...
+    ) -> None:
+        """Issue a warning, or maybe ignore it or raise an exception.
+
+  message
+    Text of the warning message.
+  category
+    The Warning category subclass. Defaults to UserWarning.
+  stacklevel
+    How far up the call stack to make this warning appear. A value of 2 for
+    example attributes the warning to the caller of the code calling warn().
+  source
+    If supplied, the destroyed object which emitted a ResourceWarning
+  skip_file_prefixes
+    An optional tuple of module filename prefixes indicating frames to skip
+    during stacklevel computations for stack frame attribution.
+"""
     @overload
     def warn(
         message: Warning,
@@ -27,7 +45,9 @@ if sys.version_info >= (3, 12):
 
 else:
     @overload
-    def warn(message: str, category: type[Warning] | None = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
+    def warn(message: str, category: type[Warning] | None = None, stacklevel: int = 1, source: Any | None = None) -> None:
+        """Issue a warning, or maybe ignore it or raise an exception.
+"""
     @overload
     def warn(message: Warning, category: Any = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
 
@@ -41,7 +61,9 @@ def warn_explicit(
     registry: dict[str | tuple[str, type[Warning], int], int] | None = None,
     module_globals: dict[str, Any] | None = None,
     source: Any | None = None,
-) -> None: ...
+) -> None:
+    """Issue a warning, or maybe ignore it or raise an exception.
+"""
 @overload
 def warn_explicit(
     message: Warning,

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

@@ -1,3 +1,5 @@
+"""Weak-reference support module.
+"""
 from collections.abc import Callable
 from typing import Any, TypeVar, overload
 from weakref import CallableProxyType as CallableProxyType, ProxyType as ProxyType, ReferenceType as ReferenceType, ref as ref
@@ -5,11 +7,20 @@ from weakref import CallableProxyType as CallableProxyType, ProxyType as ProxyTy
 _C = TypeVar("_C", bound=Callable[..., Any])
 _T = TypeVar("_T")
 
-def getweakrefcount(object: Any, /) -> int: ...
+def getweakrefcount(object: Any, /) -> int:
-def getweakrefs(object: Any, /) -> list[Any]: ...
+    """Return the number of weak references to 'object'.
+"""
+def getweakrefs(object: Any, /) -> list[Any]:
+    """Return a list of all weak reference objects pointing to 'object'.
+"""
 
 # Return CallableProxyType if object is callable, ProxyType otherwise
 @overload
-def proxy(object: _C, callback: Callable[[_C], Any] | None = None, /) -> CallableProxyType[_C]: ...
+def proxy(object: _C, callback: Callable[[_C], Any] | None = None, /) -> CallableProxyType[_C]:
+    """Create a proxy object that weakly references 'object'.
+
+'callback', if given, is called with a reference to the
+proxy when 'object' is about to be finalized.
+"""
 @overload
 def proxy(object: _T, callback: Callable[[_T], Any] | None = None, /) -> Any: ...

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

@@ -45,4 +45,8 @@ class WeakSet(MutableSet[_T]):
     def union(self, other: Iterable[_S]) -> WeakSet[_S | _T]: ...
     def __or__(self, other: Iterable[_S]) -> WeakSet[_S | _T]: ...
     def isdisjoint(self, other: Iterable[_T]) -> bool: ...
-    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+        """Represent a PEP 585 generic type
+
+E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+"""

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

@@ -1,3 +1,5 @@
+"""Implementation module for Zstandard compression.
+"""
 from _typeshed import ReadableBuffer
 from collections.abc import Mapping
 from compression.zstd import CompressionParameter, DecompressionParameter
@@ -42,6 +44,18 @@ _ZstdCompressorFlushFrame: TypeAlias = Literal[2]
 
 @final
 class ZstdCompressor:
+    """Create a compressor object for compressing data incrementally.
+
+  level
+    The compression level to use. Defaults to COMPRESSION_LEVEL_DEFAULT.
+  options
+    A dict object that contains advanced compression parameters.
+  zstd_dict
+    A ZstdDict object, a pre-trained Zstandard dictionary.
+
+Thread-safe at method level. For one-shot compression, use the compress()
+function instead.
+"""
     CONTINUE: Final = 0
     FLUSH_BLOCK: Final = 1
     FLUSH_FRAME: Final = 2
@@ -53,50 +67,239 @@ class ZstdCompressor:
     ) -> Self: ...
     def compress(
         self, /, data: ReadableBuffer, mode: _ZstdCompressorContinue | _ZstdCompressorFlushBlock | _ZstdCompressorFlushFrame = 0
-    ) -> bytes: ...
+    ) -> bytes:
-    def flush(self, /, mode: _ZstdCompressorFlushBlock | _ZstdCompressorFlushFrame = 2) -> bytes: ...
+        """Provide data to the compressor object.
-    def set_pledged_input_size(self, size: int | None, /) -> None: ...
+
+  mode
+    Can be these 3 values ZstdCompressor.CONTINUE,
+    ZstdCompressor.FLUSH_BLOCK, ZstdCompressor.FLUSH_FRAME
+
+Return a chunk of compressed data if possible, or b'' otherwise. When you have
+finished providing data to the compressor, call the flush() method to finish
+the compression process.
+"""
+    def flush(self, /, mode: _ZstdCompressorFlushBlock | _ZstdCompressorFlushFrame = 2) -> bytes:
+        """Finish the compression process.
+
+  mode
+    Can be these 2 values ZstdCompressor.FLUSH_FRAME,
+    ZstdCompressor.FLUSH_BLOCK
+
+Flush any remaining data left in internal buffers. Since Zstandard data
+consists of one or more independent frames, the compressor object can still
+be used after this method is called.
+"""
+    def set_pledged_input_size(self, size: int | None, /) -> None:
+        """Set the uncompressed content size to be written into the frame header.
+
+  size
+    The size of the uncompressed data to be provided to the compressor.
+
+This method can be used to ensure the header of the frame about to be written
+includes the size of the data, unless the CompressionParameter.content_size_flag
+is set to False. If last_mode != FLUSH_FRAME, then a RuntimeError is raised.
+
+It is important to ensure that the pledged data size matches the actual data
+size. If they do not match the compressed output data may be corrupted and the
+final chunk written may be lost.
+"""
     @property
-    def last_mode(self) -> _ZstdCompressorContinue | _ZstdCompressorFlushBlock | _ZstdCompressorFlushFrame: ...
+    def last_mode(self) -> _ZstdCompressorContinue | _ZstdCompressorFlushBlock | _ZstdCompressorFlushFrame:
+        """The last mode used to this compressor object, its value can be .CONTINUE,
+.FLUSH_BLOCK, .FLUSH_FRAME. Initialized to .FLUSH_FRAME.
+
+It can be used to get the current state of a compressor, such as, data
+flushed, or a frame ended.
+"""
 
 @final
 class ZstdDecompressor:
+    """Create a decompressor object for decompressing data incrementally.
+
+  zstd_dict
+    A ZstdDict object, a pre-trained Zstandard dictionary.
+  options
+    A dict object that contains advanced decompression parameters.
+
+Thread-safe at method level. For one-shot decompression, use the decompress()
+function instead.
+"""
     def __new__(
         cls, zstd_dict: ZstdDict | tuple[ZstdDict, int] | None = None, options: Mapping[int, int] | None = None
     ) -> Self: ...
-    def decompress(self, /, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    def decompress(self, /, data: ReadableBuffer, max_length: int = -1) -> bytes:
+        """Decompress *data*, returning uncompressed bytes if possible, or b'' otherwise.
+
+  data
+    A bytes-like object, Zstandard data to be decompressed.
+  max_length
+    Maximum size of returned data. When it is negative, the size of
+    output buffer is unlimited. When it is nonnegative, returns at
+    most max_length bytes of decompressed data.
+
+If *max_length* is nonnegative, returns at most *max_length* bytes of
+decompressed data. If this limit is reached and further output can be
+produced, *self.needs_input* will be set to ``False``. In this case, the next
+call to *decompress()* may provide *data* as b'' to obtain more of the output.
+
+If all of the input data was decompressed and returned (either because this
+was less than *max_length* bytes, or because *max_length* was negative),
+*self.needs_input* will be set to True.
+
+Attempting to decompress data after the end of a frame is reached raises an
+EOFError. Any data found after the end of the frame is ignored and saved in
+the self.unused_data attribute.
+"""
     @property
-    def eof(self) -> bool: ...
+    def eof(self) -> bool:
+        """True means the end of the first frame has been reached. If decompress data
+after that, an EOFError exception will be raised.
+"""
     @property
-    def needs_input(self) -> bool: ...
+    def needs_input(self) -> bool:
+        """If the max_length output limit in .decompress() method has been reached,
+and the decompressor has (or may has) unconsumed input data, it will be set
+to False. In this case, passing b'' to the .decompress() method may output
+further data.
+"""
     @property
-    def unused_data(self) -> bytes: ...
+    def unused_data(self) -> bytes:
+        """A bytes object of un-consumed input data.
+
+When ZstdDecompressor object stops after a frame is
+decompressed, unused input data after the frame. Otherwise this will be b''.
+"""
 
 @final
 class ZstdDict:
-    def __new__(cls, dict_content: bytes, /, *, is_raw: bool = False) -> Self: ...
+    """Represents a Zstandard dictionary.
-    def __len__(self, /) -> int: ...
-    @property
-    def as_digested_dict(self) -> tuple[Self, int]: ...
-    @property
-    def as_prefix(self) -> tuple[Self, int]: ...
-    @property
-    def as_undigested_dict(self) -> tuple[Self, int]: ...
-    @property
-    def dict_content(self) -> bytes: ...
-    @property
-    def dict_id(self) -> int: ...
 
-class ZstdError(Exception): ...
+  dict_content
+    The content of a Zstandard dictionary as a bytes-like object.
+  is_raw
+    If true, perform no checks on *dict_content*, useful for some
+    advanced cases. Otherwise, check that the content represents
+    a Zstandard dictionary created by the zstd library or CLI.
+
+The dictionary can be used for compression or decompression, and can be shared
+by multiple ZstdCompressor or ZstdDecompressor objects.
+"""
+    def __new__(cls, dict_content: bytes, /, *, is_raw: bool = False) -> Self: ...
+    def __len__(self, /) -> int:
+        """Return len(self).
+"""
+    @property
+    def as_digested_dict(self) -> tuple[Self, int]:
+        """Load as a digested dictionary to compressor.
+
+Pass this attribute as zstd_dict argument:
+compress(dat, zstd_dict=zd.as_digested_dict)
+
+1. Some advanced compression parameters of compressor may be overridden
+   by parameters of digested dictionary.
+2. ZstdDict has a digested dictionaries cache for each compression level.
+   It's faster when loading again a digested dictionary with the same
+   compression level.
+3. No need to use this for decompression.
+"""
+    @property
+    def as_prefix(self) -> tuple[Self, int]:
+        """Load as a prefix to compressor/decompressor.
+
+Pass this attribute as zstd_dict argument:
+compress(dat, zstd_dict=zd.as_prefix)
+
+1. Prefix is compatible with long distance matching, while dictionary is not.
+2. It only works for the first frame, then the compressor/decompressor will
+   return to no prefix state.
+3. When decompressing, must use the same prefix as when compressing.
+"""
+    @property
+    def as_undigested_dict(self) -> tuple[Self, int]:
+        """Load as an undigested dictionary to compressor.
+
+Pass this attribute as zstd_dict argument:
+compress(dat, zstd_dict=zd.as_undigested_dict)
+
+1. The advanced compression parameters of compressor will not be overridden.
+2. Loading an undigested dictionary is costly. If load an undigested dictionary
+   multiple times, consider reusing a compressor object.
+3. No need to use this for decompression.
+"""
+    @property
+    def dict_content(self) -> bytes:
+        """The content of a Zstandard dictionary, as a bytes object.
+"""
+    @property
+    def dict_id(self) -> int:
+        """The Zstandard dictionary, an int between 0 and 2**32.
+
+A non-zero value represents an ordinary Zstandard dictionary,
+conforming to the standardised format.
+
+A value of zero indicates a 'raw content' dictionary,
+without any restrictions on format or content.
+"""
+
+class ZstdError(Exception):
+    """An error occurred in the zstd library.
+"""
 
 def finalize_dict(
     custom_dict_bytes: bytes, samples_bytes: bytes, samples_sizes: tuple[int, ...], dict_size: int, compression_level: int, /
-) -> bytes: ...
+) -> bytes:
-def get_frame_info(frame_buffer: ReadableBuffer) -> tuple[int, int]: ...
+    """Finalize a Zstandard dictionary.
-def get_frame_size(frame_buffer: ReadableBuffer) -> int: ...
+
-def get_param_bounds(parameter: int, is_compress: bool) -> tuple[int, int]: ...
+  custom_dict_bytes
-def set_parameter_types(c_parameter_type: type[CompressionParameter], d_parameter_type: type[DecompressionParameter]) -> None: ...
+    Custom dictionary content.
-def train_dict(samples_bytes: bytes, samples_sizes: tuple[int, ...], dict_size: int, /) -> bytes: ...
+  samples_bytes
+    Concatenation of samples.
+  samples_sizes
+    Tuple of samples' sizes.
+  dict_size
+    The size of the dictionary.
+  compression_level
+    Optimize for a specific Zstandard compression level, 0 means default.
+"""
+def get_frame_info(frame_buffer: ReadableBuffer) -> tuple[int, int]:
+    """Get Zstandard frame infomation from a frame header.
+
+  frame_buffer
+    A bytes-like object, containing the header of a Zstandard frame.
+"""
+def get_frame_size(frame_buffer: ReadableBuffer) -> int:
+    """Get the size of a Zstandard frame, including the header and optional checksum.
+
+  frame_buffer
+    A bytes-like object, it should start from the beginning of a frame,
+    and contains at least one complete frame.
+"""
+def get_param_bounds(parameter: int, is_compress: bool) -> tuple[int, int]:
+    """Get CompressionParameter/DecompressionParameter bounds.
+
+  parameter
+    The parameter to get bounds.
+  is_compress
+    True for CompressionParameter, False for DecompressionParameter.
+"""
+def set_parameter_types(c_parameter_type: type[CompressionParameter], d_parameter_type: type[DecompressionParameter]) -> None:
+    """Set CompressionParameter and DecompressionParameter types for validity check.
+
+  c_parameter_type
+    CompressionParameter IntEnum type object
+  d_parameter_type
+    DecompressionParameter IntEnum type object
+"""
+def train_dict(samples_bytes: bytes, samples_sizes: tuple[int, ...], dict_size: int, /) -> bytes:
+    """Train a Zstandard dictionary on sample data.
+
+  samples_bytes
+    Concatenation of samples.
+  samples_sizes
+    Tuple of samples' sizes.
+  dict_size
+    The size of the dictionary.
+"""
 
 zstd_version: Final[str]
 zstd_version_number: Final[int]

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

@@ -1,3 +1,5 @@
+"""Abstract Base Classes (ABCs) according to PEP 3119.
+"""
 import _typeshed
 import sys
 from _typeshed import SupportsWrite
@@ -12,6 +14,18 @@ _P = ParamSpec("_P")
 
 # These definitions have special processing in mypy
 class ABCMeta(type):
+    """Metaclass for defining Abstract Base Classes (ABCs).
+
+Use this metaclass to create an ABC.  An ABC can be subclassed
+directly, and then acts as a mix-in class.  You can also register
+unrelated concrete classes (even built-in classes) and unrelated
+ABCs as 'virtual subclasses' -- these and their descendants will
+be considered subclasses of the registering ABC by the built-in
+issubclass() function, but the registering ABC won't show up in
+their MRO (Method Resolution Order) nor will method
+implementations defined by the registering ABC be callable (not
+even via super()).
+"""
     __abstractmethods__: frozenset[str]
     if sys.version_info >= (3, 11):
         def __new__(
@@ -22,30 +36,113 @@ 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:
-    def __subclasscheck__(cls: ABCMeta, subclass: type) -> bool: ...
+        """Override for isinstance(instance, cls).
-    def _dump_registry(cls: ABCMeta, file: SupportsWrite[str] | None = None) -> None: ...
+"""
-    def register(cls: ABCMeta, subclass: type[_T]) -> type[_T]: ...
+    def __subclasscheck__(cls: ABCMeta, subclass: type) -> bool:
+        """Override for issubclass(subclass, cls).
+"""
+    def _dump_registry(cls: ABCMeta, file: SupportsWrite[str] | None = None) -> None:
+        """Debug helper to print the ABC registry.
+"""
+    def register(cls: ABCMeta, subclass: type[_T]) -> type[_T]:
+        """Register a virtual subclass of an ABC.
 
-def abstractmethod(funcobj: _FuncT) -> _FuncT: ...
+Returns the subclass, to allow usage as a class decorator.
+"""
+
+def abstractmethod(funcobj: _FuncT) -> _FuncT:
+    """A decorator indicating abstract methods.
+
+Requires that the metaclass is ABCMeta or derived from it.  A
+class that has a metaclass derived from ABCMeta cannot be
+instantiated unless all of its abstract methods are overridden.
+The abstract methods can be called using any of the normal
+'super' call mechanisms.  abstractmethod() may be used to declare
+abstract methods for properties and descriptors.
+
+Usage:
+
+    class C(metaclass=ABCMeta):
+        @abstractmethod
+        def my_abstract_method(self, arg1, arg2, argN):
+            ...
+"""
 @deprecated("Deprecated since Python 3.3. Use `@classmethod` stacked on top of `@abstractmethod` instead.")
 class abstractclassmethod(classmethod[_T, _P, _R_co]):
+    """A decorator indicating abstract classmethods.
+
+Deprecated, use 'classmethod' with 'abstractmethod' instead:
+
+    class C(ABC):
+        @classmethod
+        @abstractmethod
+        def my_abstract_classmethod(cls, ...):
+            ...
+
+"""
     __isabstractmethod__: Literal[True]
     def __init__(self, callable: Callable[Concatenate[type[_T], _P], _R_co]) -> None: ...
 
 @deprecated("Deprecated since Python 3.3. Use `@staticmethod` stacked on top of `@abstractmethod` instead.")
 class abstractstaticmethod(staticmethod[_P, _R_co]):
+    """A decorator indicating abstract staticmethods.
+
+Deprecated, use 'staticmethod' with 'abstractmethod' instead:
+
+    class C(ABC):
+        @staticmethod
+        @abstractmethod
+        def my_abstract_staticmethod(...):
+            ...
+
+"""
     __isabstractmethod__: Literal[True]
     def __init__(self, callable: Callable[_P, _R_co]) -> None: ...
 
 @deprecated("Deprecated since Python 3.3. Use `@property` stacked on top of `@abstractmethod` instead.")
 class abstractproperty(property):
+    """A decorator indicating abstract properties.
+
+Deprecated, use 'property' with 'abstractmethod' instead:
+
+    class C(ABC):
+        @property
+        @abstractmethod
+        def my_abstract_property(self):
+            ...
+
+"""
     __isabstractmethod__: Literal[True]
 
 class ABC(metaclass=ABCMeta):
+    """Helper class that provides a standard way to create an ABC using
+inheritance.
+"""
     __slots__ = ()
 
-def get_cache_token() -> object: ...
+def get_cache_token() -> object:
+    """Returns the current ABC cache token.
+
+The token is an opaque object (supporting equality testing) identifying the
+current version of the ABC cache for virtual subclasses. The token changes
+with every call to register() on any ABC.
+"""
 
 if sys.version_info >= (3, 10):
-    def update_abstractmethods(cls: type[_T]) -> type[_T]: ...
+    def update_abstractmethods(cls: type[_T]) -> type[_T]:
+        """Recalculate the set of abstract methods of an abstract class.
+
+If a class has had one of its abstract methods implemented after the
+class was created, the method will not be considered implemented until
+this function is called. Alternatively, if a new abstract method has been
+added to the class, it will only be considered an abstract method of the
+class after this function is called.
+
+This function should be called before any use is made of the class,
+usually in class decorators that add methods to the subject class.
+
+Returns cls, to allow usage as a class decorator.
+
+If cls is not an instance of ABCMeta, does nothing.
+"""

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

@@ -1,3 +1,138 @@
+"""Stuff to parse AIFF-C and AIFF files.
+
+Unless explicitly stated otherwise, the description below is true
+both for AIFF-C files and AIFF files.
+
+An AIFF-C file has the following structure.
+
+  +-----------------+
+  | FORM            |
+  +-----------------+
+  | <size>          |
+  +----+------------+
+  |    | AIFC       |
+  |    +------------+
+  |    | <chunks>   |
+  |    |    .       |
+  |    |    .       |
+  |    |    .       |
+  +----+------------+
+
+An AIFF file has the string "AIFF" instead of "AIFC".
+
+A chunk consists of an identifier (4 bytes) followed by a size (4 bytes,
+big endian order), followed by the data.  The size field does not include
+the size of the 8 byte header.
+
+The following chunk types are recognized.
+
+  FVER
+      <version number of AIFF-C defining document> (AIFF-C only).
+  MARK
+      <# of markers> (2 bytes)
+      list of markers:
+          <marker ID> (2 bytes, must be > 0)
+          <position> (4 bytes)
+          <marker name> ("pstring")
+  COMM
+      <# of channels> (2 bytes)
+      <# of sound frames> (4 bytes)
+      <size of the samples> (2 bytes)
+      <sampling frequency> (10 bytes, IEEE 80-bit extended
+          floating point)
+      in AIFF-C files only:
+      <compression type> (4 bytes)
+      <human-readable version of compression type> ("pstring")
+  SSND
+      <offset> (4 bytes, not used by this program)
+      <blocksize> (4 bytes, not used by this program)
+      <sound data>
+
+A pstring consists of 1 byte length, a string of characters, and 0 or 1
+byte pad to make the total length even.
+
+Usage.
+
+Reading AIFF files:
+  f = aifc.open(file, 'r')
+where file is either the name of a file or an open file pointer.
+The open file pointer must have methods read(), seek(), and close().
+In some types of audio files, if the setpos() method is not used,
+the seek() method is not necessary.
+
+This returns an instance of a class with the following public methods:
+  getnchannels()  -- returns number of audio channels (1 for
+             mono, 2 for stereo)
+  getsampwidth()  -- returns sample width in bytes
+  getframerate()  -- returns sampling frequency
+  getnframes()    -- returns number of audio frames
+  getcomptype()   -- returns compression type ('NONE' for AIFF files)
+  getcompname()   -- returns human-readable version of
+             compression type ('not compressed' for AIFF files)
+  getparams() -- returns a namedtuple consisting of all of the
+             above in the above order
+  getmarkers()    -- get the list of marks in the audio file or None
+             if there are no marks
+  getmark(id) -- get mark with the specified id (raises an error
+             if the mark does not exist)
+  readframes(n)   -- returns at most n frames of audio
+  rewind()    -- rewind to the beginning of the audio stream
+  setpos(pos) -- seek to the specified position
+  tell()      -- return the current position
+  close()     -- close the instance (make it unusable)
+The position returned by tell(), the position given to setpos() and
+the position of marks are all compatible and have nothing to do with
+the actual position in the file.
+The close() method is called automatically when the class instance
+is destroyed.
+
+Writing AIFF files:
+  f = aifc.open(file, 'w')
+where file is either the name of a file or an open file pointer.
+The open file pointer must have methods write(), tell(), seek(), and
+close().
+
+This returns an instance of a class with the following public methods:
+  aiff()      -- create an AIFF file (AIFF-C default)
+  aifc()      -- create an AIFF-C file
+  setnchannels(n) -- set the number of channels
+  setsampwidth(n) -- set the sample width
+  setframerate(n) -- set the frame rate
+  setnframes(n)   -- set the number of frames
+  setcomptype(type, name)
+          -- set the compression type and the
+             human-readable compression type
+  setparams(tuple)
+          -- set all parameters at once
+  setmark(id, pos, name)
+          -- add specified mark to the list of marks
+  tell()      -- return current position in output file (useful
+             in combination with setmark())
+  writeframesraw(data)
+          -- write audio frames without pathing up the
+             file header
+  writeframes(data)
+          -- write audio frames and patch up the file header
+  close()     -- patch up the file header and close the
+             output file
+You should set the parameters before the first writeframesraw or
+writeframes.  The total number of frames does not need to be set,
+but when it is set to the correct value, the header does not have to
+be patched up.
+It is best to first set all parameters, perhaps possibly the
+compression type, and then write audio frames using writeframesraw.
+When all frames have been written, either call writeframes(b'') or
+close() to patch up the sizes in the header.
+Marks can be added anytime.  If there are any marks, you must call
+close() after all frames have been written.
+The close() method is called automatically when the class instance
+is destroyed.
+
+When a file is opened with the extension '.aiff', an AIFF file is
+written, otherwise an AIFF-C file is written.  This default can be
+changed by calling aiff() or aifc() before the first writeframes or
+writeframesraw.
+"""
 from types import TracebackType
 from typing import IO, Any, Literal, NamedTuple, overload
 from typing_extensions import Self, TypeAlias
@@ -7,6 +142,8 @@ __all__ = ["Error", "open"]
 class Error(Exception): ...
 
 class _aifc_params(NamedTuple):
+    """_aifc_params(nchannels, sampwidth, framerate, nframes, comptype, compname)
+"""
     nchannels: int
     sampwidth: int
     framerate: int

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

@@ -1,3 +1,5 @@
+"""Helpers for introspecting and wrapping annotations.
+"""
 import sys
 from typing import Literal
 
@@ -28,6 +30,17 @@ if sys.version_info >= (3, 14):
 
     @final
     class ForwardRef:
+        """Wrapper that holds a forward reference.
+
+Constructor arguments:
+* arg: a string representing the code to be evaluated.
+* module: the module where the forward reference was created.
+  Must be a string, not a module object.
+* owner: The owning object (module, class, or function).
+* is_argument: Does nothing, retained for compatibility.
+* is_class: True if the forward reference was created in class scope.
+
+"""
         __slots__ = (
             "__forward_is_argument__",
             "__forward_is_class__",
@@ -57,7 +70,11 @@ if sys.version_info >= (3, 14):
             type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] | None = None,
             owner: object = None,
             format: Literal[Format.STRING],
-        ) -> str: ...
+        ) -> str:
+            """Evaluate the forward reference and return the value.
+
+If the forward reference cannot be evaluated, raise an exception.
+"""
         @overload
         def evaluate(
             self,
@@ -97,7 +114,11 @@ if sys.version_info >= (3, 14):
         def __ror__(self, other: Any) -> types.UnionType: ...
 
     @overload
-    def call_evaluate_function(evaluate: EvaluateFunc, format: Literal[Format.STRING], *, owner: object = None) -> str: ...
+    def call_evaluate_function(evaluate: EvaluateFunc, format: Literal[Format.STRING], *, owner: object = None) -> str:
+        """Call an evaluate function. Evaluate functions are normally generated for
+the value of type aliases and the bounds, constraints, and defaults of
+type parameter objects.
+"""
     @overload
     def call_evaluate_function(
         evaluate: EvaluateFunc, format: Literal[Format.FORWARDREF], *, owner: object = None
@@ -107,14 +128,38 @@ if sys.version_info >= (3, 14):
     @overload
     def call_annotate_function(
         annotate: AnnotateFunc, format: Literal[Format.STRING], *, owner: object = None
-    ) -> dict[str, str]: ...
+    ) -> dict[str, str]:
+        """Call an __annotate__ function. __annotate__ functions are normally
+generated by the compiler to defer the evaluation of annotations. They
+can be called with any of the format arguments in the Format enum, but
+compiler-generated __annotate__ functions only support the VALUE format.
+This function provides additional functionality to call __annotate__
+functions with the FORWARDREF and STRING formats.
+
+*annotate* must be an __annotate__ function, which takes a single argument
+and returns a dict of annotations.
+
+*format* must be a member of the Format enum or one of the corresponding
+integer values.
+
+*owner* can be the object that owns the annotations (i.e., the module,
+class, or function that the __annotate__ function derives from). With the
+FORWARDREF format, it is used to provide better evaluation capabilities
+on the generated ForwardRef objects.
+
+"""
     @overload
     def call_annotate_function(
         annotate: AnnotateFunc, format: Literal[Format.FORWARDREF], *, owner: object = None
     ) -> dict[str, AnnotationForm | ForwardRef]: ...
     @overload
     def call_annotate_function(annotate: AnnotateFunc, format: Format, *, owner: object = None) -> dict[str, AnnotationForm]: ...
-    def get_annotate_from_class_namespace(obj: Mapping[str, object]) -> AnnotateFunc | None: ...
+    def get_annotate_from_class_namespace(obj: Mapping[str, object]) -> AnnotateFunc | None:
+        """Retrieve the annotate function from a class namespace dictionary.
+
+Return None if the namespace does not contain an annotate function.
+This is useful in metaclass ``__new__`` methods to retrieve the annotate function.
+"""
     @overload
     def get_annotations(
         obj: Any,  # any object with __annotations__ or __annotate__
@@ -123,7 +168,57 @@ if sys.version_info >= (3, 14):
         locals: Mapping[str, object] | None = None,
         eval_str: bool = False,
         format: Literal[Format.STRING],
-    ) -> dict[str, str]: ...
+    ) -> dict[str, str]:
+        """Compute the annotations dict for an object.
+
+obj may be a callable, class, module, or other object with
+__annotate__ or __annotations__ attributes.
+Passing any other object raises TypeError.
+
+The *format* parameter controls the format in which annotations are returned,
+and must be a member of the Format enum or its integer equivalent.
+For the VALUE format, the __annotations__ is tried first; if it
+does not exist, the __annotate__ function is called. The
+FORWARDREF format uses __annotations__ if it exists and can be
+evaluated, and otherwise falls back to calling the __annotate__ function.
+The SOURCE format tries __annotate__ first, and falls back to
+using __annotations__, stringified using annotations_to_string().
+
+This function handles several details for you:
+
+  * If eval_str is true, values of type str will
+    be un-stringized using eval().  This is intended
+    for use with stringized annotations
+    ("from __future__ import annotations").
+  * If obj doesn't have an annotations dict, returns an
+    empty dict.  (Functions and methods always have an
+    annotations dict; classes, modules, and other types of
+    callables may not.)
+  * Ignores inherited annotations on classes.  If a class
+    doesn't have its own annotations dict, returns an empty dict.
+  * All accesses to object members and dict values are done
+    using getattr() and dict.get() for safety.
+  * Always, always, always returns a freshly-created dict.
+
+eval_str controls whether or not values of type str are replaced
+with the result of calling eval() on those values:
+
+  * If eval_str is true, eval() is called on values of type str.
+  * If eval_str is false (the default), values of type str are unchanged.
+
+globals and locals are passed in to eval(); see the documentation
+for eval() for more information.  If either globals or locals is
+None, this function may replace that value with a context-specific
+default, contingent on type(obj):
+
+  * If obj is a module, globals defaults to obj.__dict__.
+  * If obj is a class, globals defaults to
+    sys.modules[obj.__module__].__dict__ and locals
+    defaults to the obj class namespace.
+  * If obj is a callable, globals defaults to obj.__globals__,
+    although if obj is a wrapped function (using
+    functools.update_wrapper()) it is first unwrapped.
+"""
     @overload
     def get_annotations(
         obj: Any,
@@ -142,5 +237,16 @@ if sys.version_info >= (3, 14):
         eval_str: bool = False,
         format: Format = Format.VALUE,  # noqa: Y011
     ) -> dict[str, AnnotationForm]: ...
-    def type_repr(value: object) -> str: ...
+    def type_repr(value: object) -> str:
-    def annotations_to_string(annotations: SupportsItems[str, object]) -> dict[str, str]: ...
+        """Convert a Python value to a format suitable for use with the STRING format.
+
+This is intended as a helper for tools that support the STRING format but do
+not have access to the code that originally produced the annotations. It uses
+repr() for most objects.
+
+"""
+    def annotations_to_string(annotations: SupportsItems[str, object]) -> dict[str, str]:
+        """Convert an annotation dict containing values to approximately the STRING format.
+
+Always returns a fresh a dictionary.
+"""

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

@@ -1,3 +1,65 @@
+"""Command-line parsing library
+
+This module is an optparse-inspired command-line parsing library that:
+
+    - handles both optional and positional arguments
+    - produces highly informative usage messages
+    - supports parsers that dispatch to sub-parsers
+
+The following is a simple usage example that sums integers from the
+command-line and writes the result to a file::
+
+    parser = argparse.ArgumentParser(
+        description='sum the integers at the command line')
+    parser.add_argument(
+        'integers', metavar='int', nargs='+', type=int,
+        help='an integer to be summed')
+    parser.add_argument(
+        '--log',
+        help='the file where the sum should be written')
+    args = parser.parse_args()
+    with (open(args.log, 'w') if args.log is not None
+          else contextlib.nullcontext(sys.stdout)) as log:
+        log.write('%s' % sum(args.integers))
+
+The module contains the following public classes:
+
+    - ArgumentParser -- The main entry point for command-line parsing. As the
+        example above shows, the add_argument() method is used to populate
+        the parser with actions for optional and positional arguments. Then
+        the parse_args() method is invoked to convert the args at the
+        command-line into an object with attributes.
+
+    - ArgumentError -- The exception raised by ArgumentParser objects when
+        there are errors with the parser's actions. Errors raised while
+        parsing the command-line are caught by ArgumentParser and emitted
+        as command-line messages.
+
+    - FileType -- A factory for defining types of files to be created. As the
+        example above shows, instances of FileType are typically passed as
+        the type= argument of add_argument() calls. Deprecated since
+        Python 3.14.
+
+    - Action -- The base class for parser actions. Typically actions are
+        selected by passing strings like 'store_true' or 'append_const' to
+        the action= argument of add_argument(). However, for greater
+        customization of ArgumentParser actions, subclasses of Action may
+        be defined and passed as the action= argument.
+
+    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
+        ArgumentDefaultsHelpFormatter -- Formatter classes which
+        may be passed as the formatter_class= argument to the
+        ArgumentParser constructor. HelpFormatter is the default,
+        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
+        not to change the formatting for help text, and
+        ArgumentDefaultsHelpFormatter adds information about argument defaults
+        to the help.
+
+All other classes in this module are considered implementation details.
+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
+considered public as object names -- the API of the formatter objects is
+still considered an implementation detail.)
+"""
 import sys
 from _typeshed import SupportsWrite, sentinel
 from collections.abc import Callable, Generator, Iterable, Sequence
@@ -41,12 +103,24 @@ ZERO_OR_MORE: Final = "*"
 _UNRECOGNIZED_ARGS_ATTR: Final = "_unrecognized_args"  # undocumented
 
 class ArgumentError(Exception):
+    """An error from creating or using an argument (optional or positional).
+
+The string value of this exception is the message, augmented with
+information about the argument that caused it.
+"""
     argument_name: str | None
     message: str
     def __init__(self, argument: Action | None, message: str) -> None: ...
 
 # undocumented
 class _AttributeHolder:
+    """Abstract base class that provides __repr__.
+
+The __repr__ method returns a string in the format::
+    ClassName(attr=name, attr=name, ...)
+The attributes are determined either by a class-level attribute,
+'_kwarg_names', or by inspecting the instance __dict__.
+"""
     def _get_kwargs(self) -> list[tuple[str, Any]]: ...
     def _get_args(self) -> list[Any]: ...
 
@@ -90,7 +164,11 @@ class _ActionsContainer:
         dest: str | None = ...,
         version: str = ...,
         **kwargs: Any,
-    ) -> Action: ...
+    ) -> Action:
+        """
+add_argument(dest, ..., name=value, ...)
+add_argument(option_string, option_string, ..., name=value, ...)
+"""
     def add_argument_group(
         self,
         title: str | None = None,
@@ -117,6 +195,29 @@ class _FormatterClass(Protocol):
     def __call__(self, *, prog: str) -> HelpFormatter: ...
 
 class ArgumentParser(_AttributeHolder, _ActionsContainer):
+    """Object for parsing command line strings into Python objects.
+
+Keyword Arguments:
+    - prog -- The name of the program (default:
+        ``os.path.basename(sys.argv[0])``)
+    - usage -- A usage message (default: auto-generated from arguments)
+    - description -- A description of what the program does
+    - epilog -- Text following the argument descriptions
+    - parents -- Parsers whose arguments should be copied into this one
+    - formatter_class -- HelpFormatter class for printing help messages
+    - prefix_chars -- Characters that prefix optional arguments
+    - fromfile_prefix_chars -- Characters that prefix files containing
+        additional arguments
+    - argument_default -- The default value for all arguments
+    - conflict_handler -- String indicating how to handle conflicts
+    - add_help -- Add a -h/-help option
+    - allow_abbrev -- Allow long options to be abbreviated unambiguously
+    - exit_on_error -- Determines whether or not ArgumentParser exits with
+        error info when an error occurs
+    - suggest_on_error - Enables suggestions for mistyped argument choices
+        and subparser names (default: ``False``)
+    - color - Allow color output in help messages (default: ``False``)
+"""
     prog: str
     usage: str | None
     epilog: str | None
@@ -221,7 +322,15 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     def parse_known_args(self, *, namespace: _N) -> tuple[_N, list[str]]: ...
     def convert_arg_line_to_args(self, arg_line: str) -> list[str]: ...
     def exit(self, status: int = 0, message: str | None = None) -> NoReturn: ...
-    def error(self, message: str) -> NoReturn: ...
+    def error(self, message: str) -> NoReturn:
+        """error(message: string)
+
+Prints a usage message incorporating the message to stderr and
+exits.
+
+If you override this in a subclass, it should not return -- it
+should either exit or raise an exception.
+"""
     @overload
     def parse_intermixed_args(self, args: Sequence[str] | None = None, namespace: None = None) -> Namespace: ...
     @overload
@@ -263,6 +372,11 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     def _print_message(self, message: str, file: SupportsWrite[str] | None = None) -> None: ...
 
 class HelpFormatter:
+    """Formatter for generating usage messages and argument help strings.
+
+Only the name of this class is considered a public API. All the methods
+provided by the class are considered an implementation detail.
+"""
     # undocumented
     _prog: str
     _indent_increment: int
@@ -323,12 +437,82 @@ class HelpFormatter:
     def _get_default_metavar_for_optional(self, action: Action) -> str: ...
     def _get_default_metavar_for_positional(self, action: Action) -> str: ...
 
-class RawDescriptionHelpFormatter(HelpFormatter): ...
+class RawDescriptionHelpFormatter(HelpFormatter):
-class RawTextHelpFormatter(RawDescriptionHelpFormatter): ...
+    """Help message formatter which retains any formatting in descriptions.
-class ArgumentDefaultsHelpFormatter(HelpFormatter): ...
+
-class MetavarTypeHelpFormatter(HelpFormatter): ...
+Only the name of this class is considered a public API. All the methods
+provided by the class are considered an implementation detail.
+"""
+class RawTextHelpFormatter(RawDescriptionHelpFormatter):
+    """Help message formatter which retains formatting of all help text.
+
+Only the name of this class is considered a public API. All the methods
+provided by the class are considered an implementation detail.
+"""
+class ArgumentDefaultsHelpFormatter(HelpFormatter):
+    """Help message formatter which adds default values to argument help.
+
+Only the name of this class is considered a public API. All the methods
+provided by the class are considered an implementation detail.
+"""
+class MetavarTypeHelpFormatter(HelpFormatter):
+    """Help message formatter which uses the argument 'type' as the default
+metavar value (instead of the argument 'dest')
+
+Only the name of this class is considered a public API. All the methods
+provided by the class are considered an implementation detail.
+"""
 
 class Action(_AttributeHolder):
+    """Information about how to convert command line strings to Python objects.
+
+Action objects are used by an ArgumentParser to represent the information
+needed to parse a single argument from one or more strings from the
+command line. The keyword arguments to the Action constructor are also
+all attributes of Action instances.
+
+Keyword Arguments:
+
+    - option_strings -- A list of command-line option strings which
+        should be associated with this action.
+
+    - dest -- The name of the attribute to hold the created object(s)
+
+    - nargs -- The number of command-line arguments that should be
+        consumed. By default, one argument will be consumed and a single
+        value will be produced.  Other values include:
+            - N (an integer) consumes N arguments (and produces a list)
+            - '?' consumes zero or one arguments
+            - '*' consumes zero or more arguments (and produces a list)
+            - '+' consumes one or more arguments (and produces a list)
+        Note that the difference between the default and nargs=1 is that
+        with the default, a single value will be produced, while with
+        nargs=1, a list containing a single value will be produced.
+
+    - const -- The value to be produced if the option is specified and the
+        option uses an action that takes no values.
+
+    - default -- The value to be produced if the option is not specified.
+
+    - type -- A callable that accepts a single string argument, and
+        returns the converted value.  The standard Python types str, int,
+        float, and complex are useful examples of such callables.  If None,
+        str is used.
+
+    - choices -- A container of values that should be allowed. If not None,
+        after a command-line argument has been converted to the appropriate
+        type, an exception will be raised if it is not a member of this
+        collection.
+
+    - required -- True if the action must always be specified at the
+        command line. This is only meaningful for optional command-line
+        arguments.
+
+    - help -- The help string describing the argument.
+
+    - metavar -- The name to be used for the option's argument with the
+        help string. If None, the 'dest' value will be used as the name.
+"""
     option_strings: Sequence[str]
     dest: str
     nargs: int | str | None
@@ -464,6 +648,11 @@ else:
         ) -> None: ...
 
 class Namespace(_AttributeHolder):
+    """Simple object for storing attributes.
+
+Implements equality by attribute names and values, and provides a simple
+string representation.
+"""
     def __init__(self, **kwargs: Any) -> None: ...
     def __getattr__(self, name: str) -> Any: ...
     def __setattr__(self, name: str, value: Any, /) -> None: ...
@@ -474,6 +663,21 @@ class Namespace(_AttributeHolder):
 if sys.version_info >= (3, 14):
     @deprecated("Deprecated since Python 3.14. Open files after parsing arguments instead.")
     class FileType:
+        """Deprecated factory for creating file object types
+
+Instances of FileType are typically passed as type= arguments to the
+ArgumentParser add_argument() method.
+
+Keyword Arguments:
+    - mode -- A string indicating how the file is to be opened. Accepts the
+        same values as the builtin open() function.
+    - bufsize -- The file's desired buffer size. Accepts the same values as
+        the builtin open() function.
+    - encoding -- The file's encoding. Accepts the same values as the
+        builtin open() function.
+    - errors -- A string indicating how encoding and decoding errors are to
+        be handled. Accepts the same value as the builtin open() function.
+"""
         # undocumented
         _mode: str
         _bufsize: int
@@ -486,6 +690,21 @@ if sys.version_info >= (3, 14):
 
 else:
     class FileType:
+        """Factory for creating file object types
+
+Instances of FileType are typically passed as type= arguments to the
+ArgumentParser add_argument() method.
+
+Keyword Arguments:
+    - mode -- A string indicating how the file is to be opened. Accepts the
+        same values as the builtin open() function.
+    - bufsize -- The file's desired buffer size. Accepts the same values as
+        the builtin open() function.
+    - encoding -- The file's encoding. Accepts the same values as the
+        builtin open() function.
+    - errors -- A string indicating how encoding and decoding errors are to
+        be handled. Accepts the same value as the builtin open() function.
+"""
         # undocumented
         _mode: str
         _bufsize: int
@@ -825,7 +1044,9 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
     def _get_subactions(self) -> list[Action]: ...
 
 # undocumented
-class ArgumentTypeError(Exception): ...
+class ArgumentTypeError(Exception):
+    """An error from trying to convert a command line string to a type.
+"""
 
 # undocumented
 def _get_action_name(argument: Action | None) -> str | None: ...

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

@@ -1,3 +1,8 @@
+"""This module defines an object type which can efficiently represent
+an array of basic values: characters, integers, floating-point
+numbers.  Arrays are sequence types and behave very much like lists,
+except that the type of objects stored in them is constrained.
+"""
 import sys
 from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
 from collections.abc import Iterable, MutableSequence
@@ -19,10 +24,71 @@ typecodes: str
 
 @disjoint_base
 class array(MutableSequence[_T]):
+    """array(typecode [, initializer]) -> array
+
+Return a new array whose items are restricted by typecode, and
+initialized from the optional initializer value, which must be a list,
+string or iterable over elements of the appropriate type.
+
+Arrays represent basic values and behave very much like lists, except
+the type of objects stored in them is constrained. The type is specified
+at object creation time by using a type code, which is a single character.
+The following type codes are defined:
+
+    Type code   C Type             Minimum size in bytes
+    'b'         signed integer     1
+    'B'         unsigned integer   1
+    'u'         Unicode character  2 (see note)
+    'h'         signed integer     2
+    'H'         unsigned integer   2
+    'i'         signed integer     2
+    'I'         unsigned integer   2
+    'l'         signed integer     4
+    'L'         unsigned integer   4
+    'q'         signed integer     8 (see note)
+    'Q'         unsigned integer   8 (see note)
+    'f'         floating-point     4
+    'd'         floating-point     8
+
+NOTE: The 'u' typecode corresponds to Python's unicode character. On
+narrow builds this is 2-bytes on wide builds this is 4-bytes.
+
+NOTE: The 'q' and 'Q' type codes are only available if the platform
+C compiler used to build Python supports 'long long', or, on Windows,
+'__int64'.
+
+Methods:
+
+append() -- append a new item to the end of the array
+buffer_info() -- return information giving the current memory info
+byteswap() -- byteswap all the items of the array
+count() -- return number of occurrences of an object
+extend() -- extend array by appending multiple elements from an iterable
+fromfile() -- read items from a file object
+fromlist() -- append items from the list
+frombytes() -- append items from the string
+index() -- return index of first occurrence of an object
+insert() -- insert a new item into the array at a provided position
+pop() -- remove and return item (default last)
+remove() -- remove first occurrence of an object
+reverse() -- reverse the order of the items in the array
+tofile() -- write all items to a file object
+tolist() -- return the array converted to an ordinary list
+tobytes() -- return the array converted to a string
+
+Attributes:
+
+typecode -- the typecode character used to create the array
+itemsize -- the length in bytes of one array item
+"""
     @property
-    def typecode(self) -> _TypeCode: ...
+    def typecode(self) -> _TypeCode:
+        """the typecode character used to create the array
+"""
     @property
-    def itemsize(self) -> int: ...
+    def itemsize(self) -> int:
+        """the size, in bytes, of one array item
+"""
     @overload
     def __new__(
         cls: type[array[int]], typecode: _IntTypeCode, initializer: bytes | bytearray | Iterable[int] = ..., /
@@ -52,55 +118,139 @@ class array(MutableSequence[_T]):
     def __new__(cls, typecode: str, initializer: Iterable[_T], /) -> Self: ...
     @overload
     def __new__(cls, typecode: str, initializer: bytes | bytearray = ..., /) -> Self: ...
-    def append(self, v: _T, /) -> None: ...
+    def append(self, v: _T, /) -> None:
-    def buffer_info(self) -> tuple[int, int]: ...
+        """Append new value v to the end of the array.
-    def byteswap(self) -> None: ...
+"""
-    def count(self, v: _T, /) -> int: ...
+    def buffer_info(self) -> tuple[int, int]:
-    def extend(self, bb: Iterable[_T], /) -> None: ...
+        """Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.
-    def frombytes(self, buffer: ReadableBuffer, /) -> None: ...
-    def fromfile(self, f: SupportsRead[bytes], n: int, /) -> None: ...
-    def fromlist(self, list: list[_T], /) -> None: ...
-    def fromunicode(self, ustr: str, /) -> None: ...
-    if sys.version_info >= (3, 10):
-        def index(self, v: _T, start: int = 0, stop: int = sys.maxsize, /) -> int: ...
-    else:
-        def index(self, v: _T, /) -> int: ...  # type: ignore[override]
 
-    def insert(self, i: int, v: _T, /) -> None: ...
+The length should be multiplied by the itemsize attribute to calculate
-    def pop(self, i: int = -1, /) -> _T: ...
+the buffer length in bytes.
-    def remove(self, v: _T, /) -> None: ...
+"""
-    def tobytes(self) -> bytes: ...
+    def byteswap(self) -> None:
-    def tofile(self, f: SupportsWrite[bytes], /) -> None: ...
+        """Byteswap all items of the array.
-    def tolist(self) -> list[_T]: ...
+
-    def tounicode(self) -> str: ...
+If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is
+raised.
+"""
+    def count(self, v: _T, /) -> int:
+        """Return number of occurrences of v in the array.
+"""
+    def extend(self, bb: Iterable[_T], /) -> None:
+        """Append items to the end of the array.
+"""
+    def frombytes(self, buffer: ReadableBuffer, /) -> None:
+        """Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method.
+"""
+    def fromfile(self, f: SupportsRead[bytes], n: int, /) -> None:
+        """Read n objects from the file object f and append them to the end of the array.
+"""
+    def fromlist(self, list: list[_T], /) -> None:
+        """Append items to array from list.
+"""
+    def fromunicode(self, ustr: str, /) -> None:
+        """Extends this array with data from the unicode string ustr.
+
+The array must be a unicode type array; otherwise a ValueError is raised.
+Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of
+some other type.
+"""
+    if sys.version_info >= (3, 10):
+        def index(self, v: _T, start: int = 0, stop: int = sys.maxsize, /) -> int:
+            """Return index of first occurrence of v in the array.
+
+Raise ValueError if the value is not present.
+"""
+    else:
+        def index(self, v: _T, /) -> int:  # type: ignore[override]
+            """Return index of first occurrence of v in the array.
+"""
+
+    def insert(self, i: int, v: _T, /) -> None:
+        """Insert a new item v into the array before position i.
+"""
+    def pop(self, i: int = -1, /) -> _T:
+        """Return the i-th element and delete it from the array.
+
+i defaults to -1.
+"""
+    def remove(self, v: _T, /) -> None:
+        """Remove the first occurrence of v in the array.
+"""
+    def tobytes(self) -> bytes:
+        """Convert the array to an array of machine values and return the bytes representation.
+"""
+    def tofile(self, f: SupportsWrite[bytes], /) -> None:
+        """Write all items (as machine values) to the file object f.
+"""
+    def tolist(self) -> list[_T]:
+        """Convert array to an ordinary list with the same items.
+"""
+    def tounicode(self) -> str:
+        """Extends this array with data from the unicode string ustr.
+
+Convert the array to a unicode string.  The array must be a unicode type array;
+otherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a
+unicode string from an array of some other type.
+"""
 
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __contains__(self, value: object, /) -> bool: ...
+    def __contains__(self, value: object, /) -> bool:
-    def __len__(self) -> int: ...
+        """Return bool(key in self).
+"""
+    def __len__(self) -> int:
+        """Return len(self).
+"""
     @overload
-    def __getitem__(self, key: SupportsIndex, /) -> _T: ...
+    def __getitem__(self, key: SupportsIndex, /) -> _T:
+        """Return self[key].
+"""
     @overload
     def __getitem__(self, key: slice, /) -> array[_T]: ...
     @overload  # type: ignore[override]
-    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...
+    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None:
+        """Set self[key] to value.
+"""
     @overload
     def __setitem__(self, key: slice, value: array[_T], /) -> None: ...
-    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
+    def __delitem__(self, key: SupportsIndex | slice, /) -> None:
-    def __add__(self, value: array[_T], /) -> array[_T]: ...
+        """Delete self[key].
+"""
+    def __add__(self, value: array[_T], /) -> array[_T]:
+        """Return self+value.
+"""
     def __eq__(self, value: object, /) -> bool: ...
     def __ge__(self, value: array[_T], /) -> bool: ...
     def __gt__(self, value: array[_T], /) -> bool: ...
-    def __iadd__(self, value: array[_T], /) -> Self: ...  # type: ignore[override]
+    def __iadd__(self, value: array[_T], /) -> Self:  # type: ignore[override]
-    def __imul__(self, value: int, /) -> Self: ...
+        """Implement self+=value.
+"""
+    def __imul__(self, value: int, /) -> Self:
+        """Implement self*=value.
+"""
     def __le__(self, value: array[_T], /) -> bool: ...
     def __lt__(self, value: array[_T], /) -> bool: ...
-    def __mul__(self, value: int, /) -> array[_T]: ...
+    def __mul__(self, value: int, /) -> array[_T]:
-    def __rmul__(self, value: int, /) -> array[_T]: ...
+        """Return self*value.
-    def __copy__(self) -> array[_T]: ...
+"""
-    def __deepcopy__(self, unused: Any, /) -> array[_T]: ...
+    def __rmul__(self, value: int, /) -> array[_T]:
-    def __buffer__(self, flags: int, /) -> memoryview: ...
+        """Return value*self.
-    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+"""
+    def __copy__(self) -> array[_T]:
+        """Return a copy of the array.
+"""
+    def __deepcopy__(self, unused: Any, /) -> array[_T]:
+        """Return a copy of the array.
+"""
+    def __buffer__(self, flags: int, /) -> memoryview:
+        """Return a buffer object that exposes the underlying memory of the object.
+"""
+    def __release_buffer__(self, buffer: memoryview, /) -> None:
+        """Release the buffer object that exposes the underlying memory of the object.
+"""
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585
+"""
 
 ArrayType = array

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

@@ -1,3 +1,23 @@
+"""A class supporting chat-style (command/response) protocols.
+
+This class adds support for 'chat' style protocols - where one side
+sends a 'command', and the other sends a response (examples would be
+the common internet protocols - smtp, nntp, ftp, etc..).
+
+The handle_read() method looks at the input stream for the current
+'terminator' (usually '\\r\\n' for single-line responses, '\\r\\n.\\r\\n'
+for multi-line output), calling self.found_terminator() on its
+receipt.
+
+for example:
+Say you build an async nntp client using this class.  At the start
+of the connection, you'll have self.terminator set to '\\r\\n', in
+order to process the single-line greeting.  Just before issuing a
+'LIST' command you'll set it to '\\r\\n.\\r\\n'.  The output of the LIST
+command will be accumulated (using your own 'collect_incoming_data'
+method) up to the terminator, and then control will be returned to
+you - by calling your self.found_terminator() method.
+"""
 import asyncore
 from abc import abstractmethod
 
@@ -6,16 +26,25 @@ class simple_producer:
     def more(self) -> bytes: ...
 
 class async_chat(asyncore.dispatcher):
+    """This is an abstract class.  You must derive from this class, and add
+    the two methods collect_incoming_data() and found_terminator()
+"""
     ac_in_buffer_size: int
     ac_out_buffer_size: int
     @abstractmethod
     def collect_incoming_data(self, data: bytes) -> None: ...
     @abstractmethod
     def found_terminator(self) -> None: ...
-    def set_terminator(self, term: bytes | int | None) -> None: ...
+    def set_terminator(self, term: bytes | int | None) -> None:
+        """Set the input delimiter.
+
+        Can be a fixed string of any length, an integer, or None.
+        """
     def get_terminator(self) -> bytes | int | None: ...
     def push(self, data: bytes) -> None: ...
     def push_with_producer(self, producer: simple_producer) -> None: ...
-    def close_when_done(self) -> None: ...
+    def close_when_done(self) -> None:
+        """automatically close this channel once the outgoing queue is empty
+"""
     def initiate_send(self) -> None: ...
     def discard_buffers(self) -> None: ...

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

@@ -1,3 +1,5 @@
+"""The asyncio package, tracking PEP 3156.
+"""
 # This condition is so big, it's clearer to keep to platform condition in two blocks
 # Can't NOQA on a specific line: https://github.com/plinss/flake8-noqa/issues/22
 import sys

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

@@ -1,3 +1,17 @@
+"""Base implementation of event loop.
+
+The event loop can be broken up into a multiplexer (the part
+responsible for notifying us of I/O events) and the event loop proper,
+which wraps a multiplexer with functionality for scheduling callbacks,
+immediately or at a given time in the future.
+
+Whenever a public API takes a callback, subsequent positional
+arguments will be passed to the callback if/when it is called.  This
+avoids the proliferation of trivial lambdas implementing closures.
+Keyword arguments for the callback are not supported; this is a
+conscious design decision, leaving the door open for keyword arguments
+to modify the meaning of the API call itself.
+"""
 import ssl
 import sys
 from _typeshed import FileDescriptorLike, ReadableBuffer, WriteableBuffer
@@ -59,41 +73,145 @@ class Server(AbstractServer):
     @property
     def sockets(self) -> tuple[socket, ...]: ...
     def close(self) -> None: ...
-    async def wait_closed(self) -> None: ...
+    async def wait_closed(self) -> None:
+        """Wait until server is closed and all connections are dropped.
+
+- If the server is not closed, wait.
+- If it is closed, but there are still active connections, wait.
+
+Anyone waiting here will be unblocked once both conditions
+(server is closed and all connections have been dropped)
+have become true, in either order.
+
+Historical note: In 3.11 and before, this was broken, returning
+immediately if the server was already closed, even if there
+were still active connections. An attempted fix in 3.12.0 was
+still broken, returning immediately if the server was still
+open and there were no active connections. Hopefully in 3.12.1
+we have it right.
+"""
 
 class BaseEventLoop(AbstractEventLoop):
-    def run_forever(self) -> None: ...
+    def run_forever(self) -> None:
-    def run_until_complete(self, future: _AwaitableLike[_T]) -> _T: ...
+        """Run until stop() is called.
-    def stop(self) -> None: ...
+"""
-    def is_running(self) -> bool: ...
+    def run_until_complete(self, future: _AwaitableLike[_T]) -> _T:
-    def is_closed(self) -> bool: ...
+        """Run until the Future is done.
-    def close(self) -> None: ...
+
-    async def shutdown_asyncgens(self) -> None: ...
+If the argument is a coroutine, it is wrapped in a Task.
+
+WARNING: It would be disastrous to call run_until_complete()
+with the same coroutine twice -- it would wrap it in two
+different Tasks and that can't be good.
+
+Return the Future's result, or raise its exception.
+"""
+    def stop(self) -> None:
+        """Stop running the event loop.
+
+Every callback already scheduled will still run.  This simply informs
+run_forever to stop looping after a complete iteration.
+"""
+    def is_running(self) -> bool:
+        """Returns True if the event loop is running.
+"""
+    def is_closed(self) -> bool:
+        """Returns True if the event loop was closed.
+"""
+    def close(self) -> None:
+        """Close the event loop.
+
+This clears the queues and shuts down the executor,
+but does not wait for the executor to finish.
+
+The event loop must not be running.
+"""
+    async def shutdown_asyncgens(self) -> None:
+        """Shutdown all active asynchronous generators.
+"""
     # Methods scheduling callbacks.  All these return Handles.
     def call_soon(
         self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-    ) -> Handle: ...
+    ) -> Handle:
+        """Arrange for a callback to be called as soon as possible.
+
+This operates as a FIFO queue: callbacks are called in the
+order in which they are registered.  Each callback will be
+called exactly once.
+
+Any positional arguments after the callback will be passed to
+the callback when it is called.
+"""
     def call_later(
         self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-    ) -> TimerHandle: ...
+    ) -> TimerHandle:
+        """Arrange for a callback to be called at a given time.
+
+Return a Handle: an opaque object with a cancel() method that
+can be used to cancel the call.
+
+The delay can be an int or float, expressed in seconds.  It is
+always relative to the current time.
+
+Each callback will be called exactly once.  If two callbacks
+are scheduled for exactly the same time, it is undefined which
+will be called first.
+
+Any positional arguments after the callback will be passed to
+the callback when it is called.
+"""
     def call_at(
         self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-    ) -> TimerHandle: ...
+    ) -> TimerHandle:
-    def time(self) -> float: ...
+        """Like call_later(), but uses an absolute time.
+
+Absolute time corresponds to the event loop's time() method.
+"""
+    def time(self) -> float:
+        """Return the time according to the event loop's clock.
+
+This is a float expressed in seconds since an epoch, but the
+epoch, precision, accuracy and drift are unspecified and may
+differ per event loop.
+"""
     # Future methods
-    def create_future(self) -> Future[Any]: ...
+    def create_future(self) -> Future[Any]:
+        """Create a Future object attached to the loop.
+"""
     # Tasks methods
     if sys.version_info >= (3, 11):
-        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None, context: Context | None = None) -> Task[_T]: ...
+        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None, context: Context | None = None) -> Task[_T]:
-    else:
+            """Schedule or begin executing a coroutine object.
-        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None) -> Task[_T]: ...
 
-    def set_task_factory(self, factory: _TaskFactory | None) -> None: ...
+Return a task object.
-    def get_task_factory(self) -> _TaskFactory | None: ...
+"""
+    else:
+        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None) -> Task[_T]:
+            """Schedule a coroutine object.
+
+        Return a task object.
+        """
+
+    def set_task_factory(self, factory: _TaskFactory | None) -> None:
+        """Set a task factory that will be used by loop.create_task().
+
+If factory is None the default task factory will be set.
+
+If factory is a callable, it should have a signature matching
+'(loop, coro, **kwargs)', where 'loop' will be a reference to the active
+event loop, 'coro' will be a coroutine object, and **kwargs will be
+arbitrary keyword arguments that should be passed on to Task.
+The callable must return a Task.
+"""
+    def get_task_factory(self) -> _TaskFactory | None:
+        """Return a task factory, or None if the default one is in use.
+"""
     # Methods for interacting with threads
     def call_soon_threadsafe(
         self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-    ) -> Handle: ...
+    ) -> Handle:
+        """Like call_soon(), but thread-safe.
+"""
     def run_in_executor(self, executor: Executor | None, func: Callable[[Unpack[_Ts]], _T], *args: Unpack[_Ts]) -> Future[_T]: ...
     def set_default_executor(self, executor: ThreadPoolExecutor) -> None: ...  # type: ignore[override]
     # Network I/O methods returning Futures.
@@ -128,7 +246,18 @@ class BaseEventLoop(AbstractEventLoop):
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
             all_errors: bool = False,
-        ) -> tuple[Transport, _ProtocolT]: ...
+        ) -> tuple[Transport, _ProtocolT]:
+            """Connect to a TCP server.
+
+Create a streaming transport connection to a given internet host and
+port: socket family AF_INET or socket.AF_INET6 depending on host (or
+family if specified), socket type SOCK_STREAM. protocol_factory must be
+a callable returning a protocol instance.
+
+This method is a coroutine which will try to establish the connection
+in the background.  When successful, the coroutine returns a
+(transport, protocol) pair.
+"""
         @overload
         async def create_connection(
             self,
@@ -168,7 +297,18 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_shutdown_timeout: float | None = None,
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
+        ) -> tuple[Transport, _ProtocolT]:
+            """Connect to a TCP server.
+
+        Create a streaming transport connection to a given internet host and
+        port: socket family AF_INET or socket.AF_INET6 depending on host (or
+        family if specified), socket type SOCK_STREAM. protocol_factory must be
+        a callable returning a protocol instance.
+
+        This method is a coroutine which will try to establish the connection
+        in the background.  When successful, the coroutine returns a
+        (transport, protocol) pair.
+        """
         @overload
         async def create_connection(
             self,
@@ -206,7 +346,18 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_handshake_timeout: float | None = None,
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
+        ) -> tuple[Transport, _ProtocolT]:
+            """Connect to a TCP server.
+
+        Create a streaming transport connection to a given internet host and
+        port: socket family AF_INET or socket.AF_INET6 depending on host (or
+        family if specified), socket type SOCK_STREAM. protocol_factory must be
+        a callable returning a protocol instance.
+
+        This method is a coroutine which will try to establish the connection
+        in the background.  When successful, the coroutine returns a
+        (transport, protocol) pair.
+        """
         @overload
         async def create_connection(
             self,
@@ -246,7 +397,22 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """Create a TCP server.
+
+The host parameter can be a string, in that case the TCP server is
+bound to host and port.
+
+The host parameter can also be a sequence of strings and in that case
+the TCP server is bound to all hosts of the sequence. If a host
+appears multiple times (possibly indirectly e.g. when hostnames
+resolve to the same IP address), the server is only bound once to that
+host.
+
+Return a Server object which can be used to stop the service.
+
+This method is a coroutine.
+"""
         @overload
         async def create_server(
             self,
@@ -284,7 +450,22 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """Create a TCP server.
+
+        The host parameter can be a string, in that case the TCP server is
+        bound to host and port.
+
+        The host parameter can also be a sequence of strings and in that case
+        the TCP server is bound to all hosts of the sequence. If a host
+        appears multiple times (possibly indirectly e.g. when hostnames
+        resolve to the same IP address), the server is only bound once to that
+        host.
+
+        Return a Server object which can be used to stop the service.
+
+        This method is a coroutine.
+        """
         @overload
         async def create_server(
             self,
@@ -320,7 +501,22 @@ class BaseEventLoop(AbstractEventLoop):
             reuse_port: bool | None = None,
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """Create a TCP server.
+
+        The host parameter can be a string, in that case the TCP server is
+        bound to host and port.
+
+        The host parameter can also be a sequence of strings and in that case
+        the TCP server is bound to all hosts of the sequence. If a host
+        appears multiple times (possibly indirectly e.g. when hostnames
+        resolve to the same IP address), the server is only bound once to that
+        host.
+
+        Return a Server object which can be used to stop the service.
+
+        This method is a coroutine.
+        """
         @overload
         async def create_server(
             self,
@@ -350,7 +546,12 @@ class BaseEventLoop(AbstractEventLoop):
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> Transport | None: ...
+        ) -> Transport | None:
+            """Upgrade transport to TLS.
+
+Return a new transport that *protocol* should start using
+immediately.
+"""
         async def connect_accepted_socket(
             self,
             protocol_factory: Callable[[], _ProtocolT],
@@ -370,7 +571,12 @@ class BaseEventLoop(AbstractEventLoop):
             server_side: bool = False,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> Transport | None: ...
+        ) -> Transport | None:
+            """Upgrade transport to TLS.
+
+        Return a new transport that *protocol* should start using
+        immediately.
+        """
         async def connect_accepted_socket(
             self,
             protocol_factory: Callable[[], _ProtocolT],
@@ -378,14 +584,44 @@ class BaseEventLoop(AbstractEventLoop):
             *,
             ssl: _SSLContext = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
+        ) -> tuple[Transport, _ProtocolT]:
+            """Handle an accepted connection.
+
+        This is used by servers that accept connections outside of
+        asyncio but that use asyncio to handle connections.
+
+        This method is a coroutine.  When completed, the coroutine
+        returns a (transport, protocol) pair.
+        """
 
     async def sock_sendfile(
         self, sock: socket, file: IO[bytes], offset: int = 0, count: int | None = None, *, fallback: bool | None = True
     ) -> int: ...
     async def sendfile(
         self, transport: WriteTransport, file: IO[bytes], offset: int = 0, count: int | None = None, *, fallback: bool = True
-    ) -> int: ...
+    ) -> int:
+        """Send a file to transport.
+
+Return the total number of bytes which were sent.
+
+The method uses high-performance os.sendfile if available.
+
+file must be a regular file object opened in binary mode.
+
+offset tells from where to start reading the file. If specified,
+count is the total number of bytes to transmit as opposed to
+sending the file until EOF is reached. File position is updated on
+return or also in case of error in which case file.tell()
+can be used to figure out the number of bytes
+which were sent.
+
+fallback set to True makes asyncio to manually read and send
+the file when the platform does not support the sendfile syscall
+(e.g. Windows or SSL socket on Unix).
+
+Raise SendfileNotAvailableError if the system does not support
+sendfile syscall and fallback is False.
+"""
     if sys.version_info >= (3, 11):
         async def create_datagram_endpoint(  # type: ignore[override]
             self,
@@ -399,7 +635,9 @@ class BaseEventLoop(AbstractEventLoop):
             reuse_port: bool | None = None,
             allow_broadcast: bool | None = None,
             sock: socket | None = None,
-        ) -> tuple[DatagramTransport, _ProtocolT]: ...
+        ) -> tuple[DatagramTransport, _ProtocolT]:
+            """Create datagram connection.
+"""
     else:
         async def create_datagram_endpoint(
             self,
@@ -414,7 +652,9 @@ class BaseEventLoop(AbstractEventLoop):
             reuse_port: bool | None = None,
             allow_broadcast: bool | None = None,
             sock: socket | None = None,
-        ) -> tuple[DatagramTransport, _ProtocolT]: ...
+        ) -> tuple[DatagramTransport, _ProtocolT]:
+            """Create datagram connection.
+"""
     # Pipes and subprocesses.
     async def connect_read_pipe(
         self, protocol_factory: Callable[[], _ProtocolT], pipe: Any
@@ -473,16 +713,74 @@ class BaseEventLoop(AbstractEventLoop):
     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: ...
+    def set_exception_handler(self, handler: _ExceptionHandler | None) -> None:
-    def get_exception_handler(self) -> _ExceptionHandler | None: ...
+        """Set handler as the new event loop exception handler.
-    def default_exception_handler(self, context: _Context) -> None: ...
+
-    def call_exception_handler(self, context: _Context) -> None: ...
+If handler is None, the default exception handler will
+be set.
+
+If handler is a callable object, it should have a
+signature matching '(loop, context)', where 'loop'
+will be a reference to the active event loop, 'context'
+will be a dict object (see `call_exception_handler()`
+documentation for details about context).
+"""
+    def get_exception_handler(self) -> _ExceptionHandler | None:
+        """Return an exception handler, or None if the default one is in use.
+        """
+    def default_exception_handler(self, context: _Context) -> None:
+        """Default exception handler.
+
+This is called when an exception occurs and no exception
+handler is set, and can be called by a custom exception
+handler that wants to defer to the default behavior.
+
+This default handler logs the error message and other
+context-dependent information.  In debug mode, a truncated
+stack trace is also appended showing where the given object
+(e.g. a handle or future or task) was created, if any.
+
+The context parameter has the same meaning as in
+`call_exception_handler()`.
+"""
+    def call_exception_handler(self, context: _Context) -> None:
+        """Call the current event loop's exception handler.
+
+The context argument is a dict containing the following keys:
+
+- 'message': Error message;
+- 'exception' (optional): Exception object;
+- 'future' (optional): Future instance;
+- 'task' (optional): Task instance;
+- 'handle' (optional): Handle instance;
+- 'protocol' (optional): Protocol instance;
+- 'transport' (optional): Transport instance;
+- 'socket' (optional): Socket instance;
+- 'source_traceback' (optional): Traceback of the source;
+- 'handle_traceback' (optional): Traceback of the handle;
+- 'asyncgen' (optional): Asynchronous generator that caused
+                         the exception.
+
+New keys maybe introduced in the future.
+
+Note: do not overload this method in an event loop subclass.
+For custom exception handling, use the
+`set_exception_handler()` method.
+"""
     # Debug flag management.
     def get_debug(self) -> bool: ...
     def set_debug(self, enabled: bool) -> None: ...
     if sys.version_info >= (3, 12):
-        async def shutdown_default_executor(self, timeout: float | None = None) -> None: ...
+        async def shutdown_default_executor(self, timeout: float | None = None) -> None:
+            """Schedule the shutdown of the default executor.
+
+The timeout parameter specifies the amount of time the executor will
+be given to finish joining. The default value is None, which means
+that the executor will be given an unlimited amount of time.
+"""
     else:
-        async def shutdown_default_executor(self) -> None: ...
+        async def shutdown_default_executor(self) -> None:
+            """Schedule the shutdown of the default executor.
+"""
 
     def __del__(self) -> None: ...

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

@@ -12,6 +12,16 @@ _PENDING: Final = "PENDING"  # undocumented
 _CANCELLED: Final = "CANCELLED"  # undocumented
 _FINISHED: Final = "FINISHED"  # undocumented
 
-def isfuture(obj: object) -> TypeIs[Future[Any]]: ...
+def isfuture(obj: object) -> TypeIs[Future[Any]]:
-def _format_callbacks(cb: Sequence[tuple[Callable[[futures.Future[Any]], None], Context]]) -> str: ...  # undocumented
+    """Check for a Future.
-def _future_repr_info(future: futures.Future[Any]) -> list[str]: ...  # undocumented
+
+This returns True when obj is a Future instance or is advertising
+itself as duck-type compatible by setting _asyncio_future_blocking.
+See comment in Future for more details.
+"""
+def _format_callbacks(cb: Sequence[tuple[Callable[[futures.Future[Any]], None], Context]]) -> str:  # undocumented
+    """helper function for Future.__repr__
+"""
+def _future_repr_info(future: futures.Future[Any]) -> list[str]:  # undocumented
+    """helper function for Future.__repr__
+"""

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

@@ -52,7 +52,11 @@ class BaseSubprocessTransport(transports.SubprocessTransport):
     def _pipe_connection_lost(self, fd: int, exc: BaseException | None) -> None: ...  # undocumented
     def _pipe_data_received(self, fd: int, data: bytes) -> None: ...  # undocumented
     def _process_exited(self, returncode: int) -> None: ...  # undocumented
-    async def _wait(self) -> int: ...  # undocumented
+    async def _wait(self) -> int:  # undocumented
+        """Wait until the process exit and return the process return code.
+
+This method is a coroutine.
+"""
     def _try_finish(self) -> None: ...  # undocumented
     def _call_connection_lost(self, exc: BaseException | None) -> None: ...  # undocumented
     def __del__(self) -> None: ...

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

@@ -15,6 +15,8 @@ if sys.version_info >= (3, 12):
     THREAD_JOIN_TIMEOUT: Final = 300
 
 class _SendfileMode(enum.Enum):
+    """An enumeration.
+"""
     UNSUPPORTED = 1
     TRY_NATIVE = 2
     FALLBACK = 3

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

@@ -15,14 +15,23 @@ _P = ParamSpec("_P")
 
 if sys.version_info < (3, 11):
     @deprecated("Deprecated since Python 3.8; removed in Python 3.11. Use `async def` instead.")
-    def coroutine(func: _FunctionT) -> _FunctionT: ...
+    def coroutine(func: _FunctionT) -> _FunctionT:
+        """Decorator to mark coroutines.
+
+    If the coroutine is not yielded from before it is destroyed,
+    an error message is logged.
+    """
 
 @overload
-def iscoroutinefunction(func: Callable[..., Coroutine[Any, Any, Any]]) -> bool: ...
+def iscoroutinefunction(func: Callable[..., Coroutine[Any, Any, Any]]) -> bool:
+    """Return True if func is a decorated coroutine function.
+"""
 @overload
 def iscoroutinefunction(func: Callable[_P, Awaitable[_T]]) -> TypeGuard[Callable[_P, Coroutine[Any, Any, _T]]]: ...
 @overload
 def iscoroutinefunction(func: Callable[_P, object]) -> TypeGuard[Callable[_P, Coroutine[Any, Any, Any]]]: ...
 @overload
 def iscoroutinefunction(func: object) -> TypeGuard[Callable[..., Coroutine[Any, Any, Any]]]: ...
-def iscoroutine(obj: object) -> TypeIs[Coroutine[Any, Any, Any]]: ...
+def iscoroutine(obj: object) -> TypeIs[Coroutine[Any, Any, Any]]:
+    """Return True if obj is a coroutine object.
+"""

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

@@ -1,3 +1,5 @@
+"""Event loop and event loop policy.
+"""
 import ssl
 import sys
 from _asyncio import (
@@ -73,6 +75,8 @@ class _TaskFactory(Protocol):
     def __call__(self, loop: AbstractEventLoop, factory: _CoroutineLike[_T], /) -> Future[_T]: ...
 
 class Handle:
+    """Object returned by callback registration methods.
+"""
     __slots__ = ("_callback", "_args", "_cancelled", "_loop", "_source_traceback", "_repr", "__weakref__", "_context")
     _cancelled: bool
     _args: Sequence[Any]
@@ -86,6 +90,8 @@ class Handle:
         def get_context(self) -> Context: ...
 
 class TimerHandle(Handle):
+    """Object returned by timed callback registration methods.
+"""
     __slots__ = ["_scheduled", "_when"]
     def __init__(
         self,
@@ -96,7 +102,12 @@ class TimerHandle(Handle):
         context: Context | None = None,
     ) -> None: ...
     def __hash__(self) -> int: ...
-    def when(self) -> float: ...
+    def when(self) -> float:
+        """Return a scheduled callback time.
+
+The time is an absolute timestamp, using the same time
+reference as loop.time().
+"""
     def __lt__(self, other: TimerHandle) -> bool: ...
     def __le__(self, other: TimerHandle) -> bool: ...
     def __gt__(self, other: TimerHandle) -> bool: ...
@@ -104,43 +115,93 @@ class TimerHandle(Handle):
     def __eq__(self, other: object) -> bool: ...
 
 class AbstractServer:
+    """Abstract server returned by create_server().
+"""
     @abstractmethod
-    def close(self) -> None: ...
+    def close(self) -> None:
+        """Stop serving.  This leaves existing connections open.
+"""
     if sys.version_info >= (3, 13):
         @abstractmethod
-        def close_clients(self) -> None: ...
+        def close_clients(self) -> None:
+            """Close all active connections.
+"""
         @abstractmethod
-        def abort_clients(self) -> None: ...
+        def abort_clients(self) -> None:
+            """Close all active connections immediately.
+"""
 
     async def __aenter__(self) -> Self: ...
     async def __aexit__(self, *exc: Unused) -> None: ...
     @abstractmethod
-    def get_loop(self) -> AbstractEventLoop: ...
+    def get_loop(self) -> AbstractEventLoop:
+        """Get the event loop the Server object is attached to.
+"""
     @abstractmethod
-    def is_serving(self) -> bool: ...
+    def is_serving(self) -> bool:
+        """Return True if the server is accepting connections.
+"""
     @abstractmethod
-    async def start_serving(self) -> None: ...
+    async def start_serving(self) -> None:
+        """Start accepting connections.
+
+This method is idempotent, so it can be called when
+the server is already being serving.
+"""
     @abstractmethod
-    async def serve_forever(self) -> None: ...
+    async def serve_forever(self) -> None:
+        """Start accepting connections until the coroutine is cancelled.
+
+The server is closed when the coroutine is cancelled.
+"""
     @abstractmethod
-    async def wait_closed(self) -> None: ...
+    async def wait_closed(self) -> None:
+        """Coroutine to wait until service is closed.
+"""
 
 class AbstractEventLoop:
+    """Abstract event loop.
+"""
     slow_callback_duration: float
     @abstractmethod
-    def run_forever(self) -> None: ...
+    def run_forever(self) -> None:
+        """Run the event loop until stop() is called.
+"""
     @abstractmethod
-    def run_until_complete(self, future: _AwaitableLike[_T]) -> _T: ...
+    def run_until_complete(self, future: _AwaitableLike[_T]) -> _T:
+        """Run the event loop until a Future is done.
+
+Return the Future's result, or raise its exception.
+"""
     @abstractmethod
-    def stop(self) -> None: ...
+    def stop(self) -> None:
+        """Stop the event loop as soon as reasonable.
+
+Exactly how soon that is may depend on the implementation, but
+no more I/O callbacks should be scheduled.
+"""
     @abstractmethod
-    def is_running(self) -> bool: ...
+    def is_running(self) -> bool:
+        """Return whether the event loop is currently running.
+"""
     @abstractmethod
-    def is_closed(self) -> bool: ...
+    def is_closed(self) -> bool:
+        """Returns True if the event loop was closed.
+"""
     @abstractmethod
-    def close(self) -> None: ...
+    def close(self) -> None:
+        """Close the loop.
+
+The loop should not be running.
+
+This is idempotent and irreversible.
+
+No other methods should be called after this one.
+"""
     @abstractmethod
-    async def shutdown_asyncgens(self) -> None: ...
+    async def shutdown_asyncgens(self) -> None:
+        """Shutdown all active asynchronous generators.
+"""
     # Methods scheduling callbacks.  All these return Handles.
     # "context" added in 3.9.10/3.10.2 for call_*
     @abstractmethod
@@ -300,7 +361,58 @@ class AbstractEventLoop:
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """A coroutine which creates a TCP server bound to host and port.
+
+The return value is a Server object which can be used to stop
+the service.
+
+If host is an empty string or None all interfaces are assumed
+and a list of multiple sockets will be returned (most likely
+one for IPv4 and another one for IPv6). The host parameter can also be
+a sequence (e.g. list) of hosts to bind to.
+
+family can be set to either AF_INET or AF_INET6 to force the
+socket to use IPv4 or IPv6. If not set it will be determined
+from host (defaults to AF_UNSPEC).
+
+flags is a bitmask for getaddrinfo().
+
+sock can optionally be specified in order to use a preexisting
+socket object.
+
+backlog is the maximum number of queued connections passed to
+listen() (defaults to 100).
+
+ssl can be set to an SSLContext to enable SSL over the
+accepted connections.
+
+reuse_address tells the kernel to reuse a local socket in
+TIME_WAIT state, without waiting for its natural timeout to
+expire. If not specified will automatically be set to True on
+UNIX.
+
+reuse_port tells the kernel to allow this endpoint to be bound to
+the same port as other existing endpoints are bound to, so long as
+they all set this flag when being created. This option is not
+supported on Windows.
+
+keep_alive set to True keeps connections active by enabling the
+periodic transmission of messages.
+
+ssl_handshake_timeout is the time in seconds that an SSL server
+will wait for completion of the SSL handshake before aborting the
+connection. Default is 60s.
+
+ssl_shutdown_timeout is the time in seconds that an SSL server
+will wait for completion of the SSL shutdown procedure
+before aborting the connection. Default is 30s.
+
+start_serving set to True (default) causes the created server
+to start accepting connections immediately.  When set to False,
+the user should await Server.start_serving() or Server.serve_forever()
+to make the server to start accepting connections.
+"""
         @overload
         @abstractmethod
         async def create_server(
@@ -340,7 +452,55 @@ class AbstractEventLoop:
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """A coroutine which creates a TCP server bound to host and port.
+
+        The return value is a Server object which can be used to stop
+        the service.
+
+        If host is an empty string or None all interfaces are assumed
+        and a list of multiple sockets will be returned (most likely
+        one for IPv4 and another one for IPv6). The host parameter can also be
+        a sequence (e.g. list) of hosts to bind to.
+
+        family can be set to either AF_INET or AF_INET6 to force the
+        socket to use IPv4 or IPv6. If not set it will be determined
+        from host (defaults to AF_UNSPEC).
+
+        flags is a bitmask for getaddrinfo().
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+
+        backlog is the maximum number of queued connections passed to
+        listen() (defaults to 100).
+
+        ssl can be set to an SSLContext to enable SSL over the
+        accepted connections.
+
+        reuse_address tells the kernel to reuse a local socket in
+        TIME_WAIT state, without waiting for its natural timeout to
+        expire. If not specified will automatically be set to True on
+        UNIX.
+
+        reuse_port tells the kernel to allow this endpoint to be bound to
+        the same port as other existing endpoints are bound to, so long as
+        they all set this flag when being created. This option is not
+        supported on Windows.
+
+        ssl_handshake_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL handshake before aborting the
+        connection. Default is 60s.
+
+        ssl_shutdown_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL shutdown procedure
+        before aborting the connection. Default is 30s.
+
+        start_serving set to True (default) causes the created server
+        to start accepting connections immediately.  When set to False,
+        the user should await Server.start_serving() or Server.serve_forever()
+        to make the server to start accepting connections.
+        """
         @overload
         @abstractmethod
         async def create_server(
@@ -378,7 +538,51 @@ class AbstractEventLoop:
             reuse_port: bool | None = None,
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """A coroutine which creates a TCP server bound to host and port.
+
+        The return value is a Server object which can be used to stop
+        the service.
+
+        If host is an empty string or None all interfaces are assumed
+        and a list of multiple sockets will be returned (most likely
+        one for IPv4 and another one for IPv6). The host parameter can also be
+        a sequence (e.g. list) of hosts to bind to.
+
+        family can be set to either AF_INET or AF_INET6 to force the
+        socket to use IPv4 or IPv6. If not set it will be determined
+        from host (defaults to AF_UNSPEC).
+
+        flags is a bitmask for getaddrinfo().
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+
+        backlog is the maximum number of queued connections passed to
+        listen() (defaults to 100).
+
+        ssl can be set to an SSLContext to enable SSL over the
+        accepted connections.
+
+        reuse_address tells the kernel to reuse a local socket in
+        TIME_WAIT state, without waiting for its natural timeout to
+        expire. If not specified will automatically be set to True on
+        UNIX.
+
+        reuse_port tells the kernel to allow this endpoint to be bound to
+        the same port as other existing endpoints are bound to, so long as
+        they all set this flag when being created. This option is not
+        supported on Windows.
+
+        ssl_handshake_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL handshake before aborting the
+        connection. Default is 60s.
+
+        start_serving set to True (default) causes the created server
+        to start accepting connections immediately.  When set to False,
+        the user should await Server.start_serving() or Server.serve_forever()
+        to make the server to start accepting connections.
+        """
         @overload
         @abstractmethod
         async def create_server(
@@ -410,7 +614,12 @@ class AbstractEventLoop:
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> Transport | None: ...
+        ) -> Transport | None:
+            """Upgrade a transport to TLS.
+
+Return a new transport that *protocol* should start using
+immediately.
+"""
         async def create_unix_server(
             self,
             protocol_factory: _ProtocolFactory,
@@ -422,7 +631,35 @@ class AbstractEventLoop:
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """A coroutine which creates a UNIX Domain Socket server.
+
+The return value is a Server object, which can be used to stop
+the service.
+
+path is a str, representing a file system path to bind the
+server socket to.
+
+sock can optionally be specified in order to use a preexisting
+socket object.
+
+backlog is the maximum number of queued connections passed to
+listen() (defaults to 100).
+
+ssl can be set to an SSLContext to enable SSL over the
+accepted connections.
+
+ssl_handshake_timeout is the time in seconds that an SSL server
+will wait for the SSL handshake to complete (defaults to 60s).
+
+ssl_shutdown_timeout is the time in seconds that an SSL server
+will wait for the SSL shutdown to finish (defaults to 30s).
+
+start_serving set to True (default) causes the created server
+to start accepting connections immediately.  When set to False,
+the user should await Server.start_serving() or Server.serve_forever()
+to make the server to start accepting connections.
+"""
     else:
         @abstractmethod
         async def start_tls(
@@ -434,7 +671,12 @@ class AbstractEventLoop:
             server_side: bool = False,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> Transport | None: ...
+        ) -> Transport | None:
+            """Upgrade a transport to TLS.
+
+        Return a new transport that *protocol* should start using
+        immediately.
+        """
         async def create_unix_server(
             self,
             protocol_factory: _ProtocolFactory,
@@ -445,7 +687,32 @@ class AbstractEventLoop:
             ssl: _SSLContext = None,
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
-        ) -> Server: ...
+        ) -> Server:
+            """A coroutine which creates a UNIX Domain Socket server.
+
+        The return value is a Server object, which can be used to stop
+        the service.
+
+        path is a str, representing a file system path to bind the
+        server socket to.
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+
+        backlog is the maximum number of queued connections passed to
+        listen() (defaults to 100).
+
+        ssl can be set to an SSLContext to enable SSL over the
+        accepted connections.
+
+        ssl_handshake_timeout is the time in seconds that an SSL server
+        will wait for the SSL handshake to complete (defaults to 60s).
+
+        start_serving set to True (default) causes the created server
+        to start accepting connections immediately.  When set to False,
+        the user should await Server.start_serving() or Server.serve_forever()
+        to make the server to start accepting connections.
+        """
 
     if sys.version_info >= (3, 11):
         async def connect_accepted_socket(
@@ -456,7 +723,15 @@ class AbstractEventLoop:
             ssl: _SSLContext = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
+        ) -> tuple[Transport, _ProtocolT]:
+            """Handle an accepted connection.
+
+This is used by servers that accept connections outside of
+asyncio, but use asyncio to handle connections.
+
+This method is a coroutine.  When completed, the coroutine
+returns a (transport, protocol) pair.
+"""
     elif sys.version_info >= (3, 10):
         async def connect_accepted_socket(
             self,
@@ -465,7 +740,15 @@ class AbstractEventLoop:
             *,
             ssl: _SSLContext = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
+        ) -> tuple[Transport, _ProtocolT]:
+            """Handle an accepted connection.
+
+        This is used by servers that accept connections outside of
+        asyncio, but use asyncio to handle connections.
+
+        This method is a coroutine.  When completed, the coroutine
+        returns a (transport, protocol) pair.
+        """
     if sys.version_info >= (3, 11):
         async def create_unix_connection(
             self,
@@ -497,7 +780,11 @@ class AbstractEventLoop:
     @abstractmethod
     async def sendfile(
         self, transport: WriteTransport, file: IO[bytes], offset: int = 0, count: int | None = None, *, fallback: bool = True
-    ) -> int: ...
+    ) -> int:
+        """Send a file through a transport.
+
+Return an amount of sent bytes.
+"""
     @abstractmethod
     async def create_datagram_endpoint(
         self,
@@ -512,16 +799,58 @@ class AbstractEventLoop:
         reuse_port: bool | None = None,
         allow_broadcast: bool | None = None,
         sock: socket | None = None,
-    ) -> tuple[DatagramTransport, _ProtocolT]: ...
+    ) -> tuple[DatagramTransport, _ProtocolT]:
+        """A coroutine which creates a datagram endpoint.
+
+This method will try to establish the endpoint in the background.
+When successful, the coroutine returns a (transport, protocol) pair.
+
+protocol_factory must be a callable returning a protocol instance.
+
+socket family AF_INET, socket.AF_INET6 or socket.AF_UNIX depending on
+host (or family if specified), socket type SOCK_DGRAM.
+
+reuse_address tells the kernel to reuse a local socket in
+TIME_WAIT state, without waiting for its natural timeout to
+expire. If not specified it will automatically be set to True on
+UNIX.
+
+reuse_port tells the kernel to allow this endpoint to be bound to
+the same port as other existing endpoints are bound to, so long as
+they all set this flag when being created. This option is not
+supported on Windows and some UNIX's. If the
+:py:data:`~socket.SO_REUSEPORT` constant is not defined then this
+capability is unsupported.
+
+allow_broadcast tells the kernel to allow this endpoint to send
+messages to the broadcast address.
+
+sock can optionally be specified in order to use a preexisting
+socket object.
+"""
     # Pipes and subprocesses.
     @abstractmethod
     async def connect_read_pipe(
         self, protocol_factory: Callable[[], _ProtocolT], pipe: Any
-    ) -> tuple[ReadTransport, _ProtocolT]: ...
+    ) -> tuple[ReadTransport, _ProtocolT]:
+        """Register read pipe in event loop. Set the pipe to non-blocking mode.
+
+protocol_factory should instantiate object with Protocol interface.
+pipe is a file-like object.
+Return pair (transport, protocol), where transport supports the
+ReadTransport interface.
+"""
     @abstractmethod
     async def connect_write_pipe(
         self, protocol_factory: Callable[[], _ProtocolT], pipe: Any
-    ) -> tuple[WriteTransport, _ProtocolT]: ...
+    ) -> tuple[WriteTransport, _ProtocolT]:
+        """Register write pipe in event loop.
+
+protocol_factory should instantiate object with BaseProtocol interface.
+Pipe is file-like object already switched to nonblocking.
+Return pair (transport, protocol), where transport support
+WriteTransport interface.
+"""
     @abstractmethod
     async def subprocess_shell(
         self,
@@ -600,16 +929,34 @@ class AbstractEventLoop:
     @abstractmethod
     def set_debug(self, enabled: bool) -> None: ...
     @abstractmethod
-    async def shutdown_default_executor(self) -> None: ...
+    async def shutdown_default_executor(self) -> None:
+        """Schedule the shutdown of the default executor.
+"""
 
 if sys.version_info >= (3, 14):
     class _AbstractEventLoopPolicy:
+        """Abstract policy for accessing the event loop.
+"""
         @abstractmethod
-        def get_event_loop(self) -> AbstractEventLoop: ...
+        def get_event_loop(self) -> AbstractEventLoop:
+            """Get the event loop for the current context.
+
+Returns an event loop object implementing the AbstractEventLoop interface,
+or raises an exception in case no event loop has been set for the
+current context and the current policy does not specify to create one.
+
+It should never return None.
+"""
         @abstractmethod
-        def set_event_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        def set_event_loop(self, loop: AbstractEventLoop | None) -> None:
+            """Set the event loop for the current context to loop.
+"""
         @abstractmethod
-        def new_event_loop(self) -> AbstractEventLoop: ...
+        def new_event_loop(self) -> AbstractEventLoop:
+            """Create and return a new event loop object according to this
+policy's rules. If there's need to set this loop as the event loop for
+the current context, set_event_loop must be called explicitly.
+"""
 
 else:
     @type_check_only
@@ -638,38 +985,108 @@ else:
 
 if sys.version_info >= (3, 14):
     class _BaseDefaultEventLoopPolicy(_AbstractEventLoopPolicy, metaclass=ABCMeta):
-        def get_event_loop(self) -> AbstractEventLoop: ...
+        """Default policy implementation for accessing the event loop.
-        def set_event_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
-        def new_event_loop(self) -> AbstractEventLoop: ...
+In this policy, each thread has its own event loop.  However, we
+only automatically create an event loop by default for the main
+thread; other threads by default have no event loop.
+
+Other policies may have different rules (e.g. a single global
+event loop, or automatically creating an event loop per thread, or
+using some other notion of context to which an event loop is
+associated).
+"""
+        def get_event_loop(self) -> AbstractEventLoop:
+            """Get the event loop for the current context.
+
+Returns an instance of EventLoop or raises an exception.
+"""
+        def set_event_loop(self, loop: AbstractEventLoop | None) -> None:
+            """Set the event loop.
+"""
+        def new_event_loop(self) -> AbstractEventLoop:
+            """Create a new event loop.
+
+You must call set_event_loop() to make this the current event
+loop.
+"""
 
 else:
     class BaseDefaultEventLoopPolicy(_AbstractEventLoopPolicy, metaclass=ABCMeta):
-        def get_event_loop(self) -> AbstractEventLoop: ...
+        """Default policy implementation for accessing the event loop.
-        def set_event_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
-        def new_event_loop(self) -> AbstractEventLoop: ...
+In this policy, each thread has its own event loop.  However, we
+only automatically create an event loop by default for the main
+thread; other threads by default have no event loop.
+
+Other policies may have different rules (e.g. a single global
+event loop, or automatically creating an event loop per thread, or
+using some other notion of context to which an event loop is
+associated).
+"""
+        def get_event_loop(self) -> AbstractEventLoop:
+            """Get the event loop for the current context.
+
+Returns an instance of EventLoop or raises an exception.
+"""
+        def set_event_loop(self, loop: AbstractEventLoop | None) -> None:
+            """Set the event loop.
+"""
+        def new_event_loop(self) -> AbstractEventLoop:
+            """Create a new event loop.
+
+You must call set_event_loop() to make this the current event
+loop.
+"""
 
 if sys.version_info >= (3, 14):
-    def _get_event_loop_policy() -> _AbstractEventLoopPolicy: ...
+    def _get_event_loop_policy() -> _AbstractEventLoopPolicy:
-    def _set_event_loop_policy(policy: _AbstractEventLoopPolicy | None) -> None: ...
+        """Get the current event loop policy.
+"""
+    def _set_event_loop_policy(policy: _AbstractEventLoopPolicy | None) -> None:
+        """Set the current event loop policy.
+
+If policy is None, the default policy is restored.
+"""
     @deprecated("Deprecated since Python 3.14; will be removed in Python 3.16.")
     def get_event_loop_policy() -> _AbstractEventLoopPolicy: ...
     @deprecated("Deprecated since Python 3.14; will be removed in Python 3.16.")
     def set_event_loop_policy(policy: _AbstractEventLoopPolicy | None) -> None: ...
 
 else:
-    def get_event_loop_policy() -> _AbstractEventLoopPolicy: ...
+    def get_event_loop_policy() -> _AbstractEventLoopPolicy:
-    def set_event_loop_policy(policy: _AbstractEventLoopPolicy | None) -> None: ...
+        """Get the current event loop policy.
+"""
+    def set_event_loop_policy(policy: _AbstractEventLoopPolicy | None) -> None:
+        """Set the current event loop policy.
 
-def set_event_loop(loop: AbstractEventLoop | None) -> None: ...
+If policy is None, the default policy is restored.
-def new_event_loop() -> AbstractEventLoop: ...
+"""
+
+def set_event_loop(loop: AbstractEventLoop | None) -> None:
+    """Equivalent to calling get_event_loop_policy().set_event_loop(loop).
+"""
+def new_event_loop() -> AbstractEventLoop:
+    """Equivalent to calling get_event_loop_policy().new_event_loop().
+"""
 
 if sys.version_info < (3, 14):
     if sys.version_info >= (3, 12):
         @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
-        def get_child_watcher() -> AbstractChildWatcher: ...
+        def get_child_watcher() -> AbstractChildWatcher:
+            """Equivalent to calling get_event_loop_policy().get_child_watcher().
+"""
         @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
-        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+        def set_child_watcher(watcher: AbstractChildWatcher) -> None:
+            """Equivalent to calling
+get_event_loop_policy().set_child_watcher(watcher).
+"""
 
     else:
-        def get_child_watcher() -> AbstractChildWatcher: ...
+        def get_child_watcher() -> AbstractChildWatcher:
-        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+            """Equivalent to calling get_event_loop_policy().get_child_watcher().
+"""
+        def set_child_watcher(watcher: AbstractChildWatcher) -> None:
+            """Equivalent to calling
+    get_event_loop_policy().set_child_watcher(watcher).
+"""

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

@@ -1,3 +1,5 @@
+"""asyncio exceptions.
+"""
 import sys
 
 # Keep asyncio.__all__ updated with any changes to __all__ here
@@ -21,24 +23,48 @@ else:
         "SendfileNotAvailableError",
     )
 
-class CancelledError(BaseException): ...
+class CancelledError(BaseException):
+    """The Future or Task was cancelled.
+"""
 
 if sys.version_info >= (3, 11):
     from builtins import TimeoutError as TimeoutError
 else:
-    class TimeoutError(Exception): ...
+    class TimeoutError(Exception):
+        """The operation exceeded the given deadline.
+"""
 
-class InvalidStateError(Exception): ...
+class InvalidStateError(Exception):
-class SendfileNotAvailableError(RuntimeError): ...
+    """The operation is not allowed in this state.
+"""
+class SendfileNotAvailableError(RuntimeError):
+    """Sendfile syscall is not available.
+
+Raised if OS does not support sendfile syscall for given socket or
+file type.
+"""
 
 class IncompleteReadError(EOFError):
+    """
+Incomplete read error. Attributes:
+
+- partial: read bytes string before the end of stream was reached
+- expected: total number of expected bytes (or None if unknown)
+"""
     expected: int | None
     partial: bytes
     def __init__(self, partial: bytes, expected: int | None) -> None: ...
 
 class LimitOverrunError(Exception):
+    """Reached the buffer limit while looking for a separator.
+
+Attributes:
+- consumed: total number of to be consumed bytes.
+"""
     consumed: int
     def __init__(self, message: str, consumed: int) -> None: ...
 
 if sys.version_info >= (3, 11):
-    class BrokenBarrierError(RuntimeError): ...
+    class BrokenBarrierError(RuntimeError):
+        """Barrier is broken by barrier.abort() call.
+"""

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

@@ -19,14 +19,29 @@ def _get_function_source(func: object) -> tuple[str, int] | None: ...
 
 if sys.version_info >= (3, 13):
     def _format_callback_source(func: object, args: Iterable[Any], *, debug: bool = False) -> str: ...
-    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any], *, debug: bool = False) -> str: ...
+    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any], *, debug: bool = False) -> str:
+        """Format function arguments and keyword arguments.
+
+Special case for a single parameter: ('hello',) is formatted as ('hello').
+
+Note that this function only returns argument details when
+debug=True is specified, as arguments may contain sensitive
+information.
+"""
     def _format_callback(
         func: object, args: Iterable[Any], kwargs: dict[str, Any], *, debug: bool = False, suffix: str = ""
     ) -> str: ...
 
 else:
     def _format_callback_source(func: object, args: Iterable[Any]) -> str: ...
-    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any]) -> str: ...
+    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any]) -> str:
+        """Format function arguments and keyword arguments.
+
+    Special case for a single parameter: ('hello',) is formatted as ('hello').
+    """
     def _format_callback(func: object, args: Iterable[Any], kwargs: dict[str, Any], suffix: str = "") -> str: ...
 
-def extract_stack(f: FrameType | None = None, limit: int | None = None) -> traceback.StackSummary: ...
+def extract_stack(f: FrameType | None = None, limit: int | None = None) -> traceback.StackSummary:
+    """Replacement for traceback.extract_stack() that only does the
+necessary work for asyncio debug mode.
+"""

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

@@ -1,3 +1,5 @@
+"""A Future class similar to the one in PEP 3148.
+"""
 import sys
 from _asyncio import Future as Future
 from concurrent.futures._base import Future as _ConcurrentFuture
@@ -16,4 +18,6 @@ else:
 
 _T = TypeVar("_T")
 
-def wrap_future(future: _ConcurrentFuture[_T] | Future[_T], *, loop: AbstractEventLoop | None = None) -> Future[_T]: ...
+def wrap_future(future: _ConcurrentFuture[_T] | Future[_T], *, loop: AbstractEventLoop | None = None) -> Future[_T]:
+    """Wrap concurrent.futures.Future object.
+"""

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

@@ -1,3 +1,5 @@
+"""Introspection utils for tasks call graphs.
+"""
 import sys
 from _typeshed import SupportsWrite
 from asyncio import Future
@@ -10,19 +12,62 @@ if sys.version_info >= (3, 14):
 
     @dataclass(frozen=True, slots=True)
     class FrameCallGraphEntry:
+        """FrameCallGraphEntry(frame: frame)
+"""
         frame: FrameType
 
     @dataclass(frozen=True, slots=True)
     class FutureCallGraph:
+        """FutureCallGraph(future: _asyncio.Future, call_stack: tuple['FrameCallGraphEntry', ...], awaited_by: tuple['FutureCallGraph', ...])
+"""
         future: Future[Any]
         call_stack: tuple[FrameCallGraphEntry, ...]
         awaited_by: tuple[FutureCallGraph, ...]
 
     @overload
-    def capture_call_graph(future: None = None, /, *, depth: int = 1, limit: int | None = None) -> FutureCallGraph | None: ...
+    def capture_call_graph(future: None = None, /, *, depth: int = 1, limit: int | None = None) -> FutureCallGraph | None:
+        """Capture the async call graph for the current task or the provided Future.
+
+The graph is represented with three data structures:
+
+* FutureCallGraph(future, call_stack, awaited_by)
+
+  Where 'future' is an instance of asyncio.Future or asyncio.Task.
+
+  'call_stack' is a tuple of FrameGraphEntry objects.
+
+  'awaited_by' is a tuple of FutureCallGraph objects.
+
+* FrameCallGraphEntry(frame)
+
+  Where 'frame' is a frame object of a regular Python function
+  in the call stack.
+
+Receives an optional 'future' argument. If not passed,
+the current task will be used. If there's no current task, the function
+returns None.
+
+If "capture_call_graph()" is introspecting *the current task*, the
+optional keyword-only 'depth' argument can be used to skip the specified
+number of frames from top of the stack.
+
+If the optional keyword-only 'limit' argument is provided, each call stack
+in the resulting graph is truncated to include at most ``abs(limit)``
+entries. If 'limit' is positive, the entries left are the closest to
+the invocation point. If 'limit' is negative, the topmost entries are
+left. If 'limit' is omitted or None, all entries are present.
+If 'limit' is 0, the call stack is not captured at all, only
+"awaited by" information is present.
+"""
     @overload
     def capture_call_graph(future: Future[Any], /, *, depth: int = 1, limit: int | None = None) -> FutureCallGraph | None: ...
-    def format_call_graph(future: Future[Any] | None = None, /, *, depth: int = 1, limit: int | None = None) -> str: ...
+    def format_call_graph(future: Future[Any] | None = None, /, *, depth: int = 1, limit: int | None = None) -> str:
+        """Return the async call graph as a string for `future`.
+
+If `future` is not provided, format the call graph for the current task.
+"""
     def print_call_graph(
         future: Future[Any] | None = None, /, *, file: SupportsWrite[str] | None = None, depth: int = 1, limit: int | None = None
-    ) -> None: ...
+    ) -> None:
+        """Print the async call graph for the current task or the provided Future.
+"""

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

@@ -1,3 +1,5 @@
+"""Synchronization primitives.
+"""
 import enum
 import sys
 from _typeshed import Unused
@@ -30,29 +32,127 @@ class _ContextManagerMixin:
     ) -> None: ...
 
 class Lock(_ContextManagerMixin, _LoopBoundMixin):
+    """Primitive lock objects.
+
+A primitive lock is a synchronization primitive that is not owned
+by a particular task when locked.  A primitive lock is in one
+of two states, 'locked' or 'unlocked'.
+
+It is created in the unlocked state.  It has two basic methods,
+acquire() and release().  When the state is unlocked, acquire()
+changes the state to locked and returns immediately.  When the
+state is locked, acquire() blocks until a call to release() in
+another task changes it to unlocked, then the acquire() call
+resets it to locked and returns.  The release() method should only
+be called in the locked state; it changes the state to unlocked
+and returns immediately.  If an attempt is made to release an
+unlocked lock, a RuntimeError will be raised.
+
+When more than one task is blocked in acquire() waiting for
+the state to turn to unlocked, only one task proceeds when a
+release() call resets the state to unlocked; successive release()
+calls will unblock tasks in FIFO order.
+
+Locks also support the asynchronous context management protocol.
+'async with lock' statement should be used.
+
+Usage:
+
+    lock = Lock()
+    ...
+    await lock.acquire()
+    try:
+        ...
+    finally:
+        lock.release()
+
+Context manager usage:
+
+    lock = Lock()
+    ...
+    async with lock:
+         ...
+
+Lock objects can be tested for locking state:
+
+    if not lock.locked():
+       await lock.acquire()
+    else:
+       # lock is acquired
+       ...
+
+"""
     _waiters: deque[Future[Any]] | None
     if sys.version_info >= (3, 10):
         def __init__(self) -> None: ...
     else:
         def __init__(self, *, loop: AbstractEventLoop | None = None) -> None: ...
 
-    def locked(self) -> bool: ...
+    def locked(self) -> bool:
-    async def acquire(self) -> Literal[True]: ...
+        """Return True if lock is acquired.
-    def release(self) -> None: ...
+"""
+    async def acquire(self) -> Literal[True]:
+        """Acquire a lock.
+
+This method blocks until the lock is unlocked, then sets it to
+locked and returns True.
+"""
+    def release(self) -> None:
+        """Release a lock.
+
+When the lock is locked, reset it to unlocked, and return.
+If any other tasks are blocked waiting for the lock to become
+unlocked, allow exactly one of them to proceed.
+
+When invoked on an unlocked lock, a RuntimeError is raised.
+
+There is no return value.
+"""
 
 class Event(_LoopBoundMixin):
+    """Asynchronous equivalent to threading.Event.
+
+Class implementing event objects. An event manages a flag that can be set
+to true with the set() method and reset to false with the clear() method.
+The wait() method blocks until the flag is true. The flag is initially
+false.
+"""
     _waiters: deque[Future[Any]]
     if sys.version_info >= (3, 10):
         def __init__(self) -> None: ...
     else:
         def __init__(self, *, loop: AbstractEventLoop | None = None) -> None: ...
 
-    def is_set(self) -> bool: ...
+    def is_set(self) -> bool:
-    def set(self) -> None: ...
+        """Return True if and only if the internal flag is true.
-    def clear(self) -> None: ...
+"""
-    async def wait(self) -> Literal[True]: ...
+    def set(self) -> None:
+        """Set the internal flag to true. All tasks waiting for it to
+become true are awakened. Tasks that call wait() once the flag is
+true will not block at all.
+"""
+    def clear(self) -> None:
+        """Reset the internal flag to false. Subsequently, tasks calling
+wait() will block until set() is called to set the internal flag
+to true again.
+"""
+    async def wait(self) -> Literal[True]:
+        """Block until the internal flag is true.
+
+If the internal flag is true on entry, return True
+immediately.  Otherwise, block until another task calls
+set() to set the flag to true, then return True.
+"""
 
 class Condition(_ContextManagerMixin, _LoopBoundMixin):
+    """Asynchronous equivalent to threading.Condition.
+
+This class implements condition variable objects. A condition variable
+allows one or more tasks to wait until they are notified by another
+task.
+
+A new Lock object is created and used as the underlying lock.
+"""
     _waiters: deque[Future[Any]]
     if sys.version_info >= (3, 10):
         def __init__(self, lock: Lock | None = None) -> None: ...
@@ -62,12 +162,62 @@ class Condition(_ContextManagerMixin, _LoopBoundMixin):
     def locked(self) -> bool: ...
     async def acquire(self) -> Literal[True]: ...
     def release(self) -> None: ...
-    async def wait(self) -> Literal[True]: ...
+    async def wait(self) -> Literal[True]:
-    async def wait_for(self, predicate: Callable[[], _T]) -> _T: ...
+        """Wait until notified.
-    def notify(self, n: int = 1) -> None: ...
+
-    def notify_all(self) -> None: ...
+If the calling task has not acquired the lock when this
+method is called, a RuntimeError is raised.
+
+This method releases the underlying lock, and then blocks
+until it is awakened by a notify() or notify_all() call for
+the same condition variable in another task.  Once
+awakened, it re-acquires the lock and returns True.
+
+This method may return spuriously,
+which is why the caller should always
+re-check the state and be prepared to wait() again.
+"""
+    async def wait_for(self, predicate: Callable[[], _T]) -> _T:
+        """Wait until a predicate becomes true.
+
+The predicate should be a callable whose result will be
+interpreted as a boolean value.  The method will repeatedly
+wait() until it evaluates to true.  The final predicate value is
+the return value.
+"""
+    def notify(self, n: int = 1) -> None:
+        """By default, wake up one task waiting on this condition, if any.
+If the calling task has not acquired the lock when this method
+is called, a RuntimeError is raised.
+
+This method wakes up n of the tasks waiting for the condition
+ variable; if fewer than n are waiting, they are all awoken.
+
+Note: an awakened task does not actually return from its
+wait() call until it can reacquire the lock. Since notify() does
+not release the lock, its caller should.
+"""
+    def notify_all(self) -> None:
+        """Wake up all tasks waiting on this condition. This method acts
+like notify(), but wakes up all waiting tasks instead of one. If the
+calling task has not acquired the lock when this method is called,
+a RuntimeError is raised.
+"""
 
 class Semaphore(_ContextManagerMixin, _LoopBoundMixin):
+    """A Semaphore implementation.
+
+A semaphore manages an internal counter which is decremented by each
+acquire() call and incremented by each release() call. The counter
+can never go below zero; when acquire() finds that it is zero, it blocks,
+waiting until some other thread calls release().
+
+Semaphores also support the context management protocol.
+
+The optional argument gives the initial value for the internal
+counter; it defaults to 1. If the value given is less than 0,
+ValueError is raised.
+"""
     _value: int
     _waiters: deque[Future[Any]] | None
     if sys.version_info >= (3, 10):
@@ -75,12 +225,34 @@ class Semaphore(_ContextManagerMixin, _LoopBoundMixin):
     else:
         def __init__(self, value: int = 1, *, loop: AbstractEventLoop | None = None) -> None: ...
 
-    def locked(self) -> bool: ...
+    def locked(self) -> bool:
-    async def acquire(self) -> Literal[True]: ...
+        """Returns True if semaphore cannot be acquired immediately.
-    def release(self) -> None: ...
+"""
-    def _wake_up_next(self) -> None: ...
+    async def acquire(self) -> Literal[True]:
+        """Acquire a semaphore.
 
-class BoundedSemaphore(Semaphore): ...
+If the internal counter is larger than zero on entry,
+decrement it by one and return True immediately.  If it is
+zero on entry, block, waiting until some other task has
+called release() to make it larger than 0, and then return
+True.
+"""
+    def release(self) -> None:
+        """Release a semaphore, incrementing the internal counter by one.
+
+When it was zero on entry and another task is waiting for it to
+become larger than zero again, wake up that task.
+"""
+    def _wake_up_next(self) -> None:
+        """Wake up the first waiter that isn't done.
+"""
+
+class BoundedSemaphore(Semaphore):
+    """A bounded semaphore implementation.
+
+This raises ValueError in release() if it would increase the value
+above the initial value.
+"""
 
 if sys.version_info >= (3, 11):
     class _BarrierState(enum.Enum):  # undocumented
@@ -90,15 +262,46 @@ if sys.version_info >= (3, 11):
         BROKEN = "broken"
 
     class Barrier(_LoopBoundMixin):
-        def __init__(self, parties: int) -> None: ...
+        """Asyncio equivalent to threading.Barrier
+
+Implements a Barrier primitive.
+Useful for synchronizing a fixed number of tasks at known synchronization
+points. Tasks block on 'wait()' and are simultaneously awoken once they
+have all made their call.
+"""
+        def __init__(self, parties: int) -> None:
+            """Create a barrier, initialised to 'parties' tasks.
+"""
         async def __aenter__(self) -> Self: ...
         async def __aexit__(self, *args: Unused) -> None: ...
-        async def wait(self) -> int: ...
+        async def wait(self) -> int:
-        async def abort(self) -> None: ...
+            """Wait for the barrier.
-        async def reset(self) -> None: ...
+
+When the specified number of tasks have started waiting, they are all
+simultaneously awoken.
+Returns an unique and individual index number from 0 to 'parties-1'.
+"""
+        async def abort(self) -> None:
+            """Place the barrier into a 'broken' state.
+
+Useful in case of error.  Any currently waiting tasks and tasks
+attempting to 'wait()' will have BrokenBarrierError raised.
+"""
+        async def reset(self) -> None:
+            """Reset the barrier to the initial state.
+
+Any tasks currently waiting will get the BrokenBarrier exception
+raised.
+"""
         @property
-        def parties(self) -> int: ...
+        def parties(self) -> int:
+            """Return the number of tasks required to trip the barrier.
+"""
         @property
-        def n_waiting(self) -> int: ...
+        def n_waiting(self) -> int:
+            """Return the number of tasks currently waiting at the barrier.
+"""
         @property
-        def broken(self) -> bool: ...
+        def broken(self) -> bool:
+            """Return True if the barrier is in a broken state.
+"""

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

@@ -1,3 +1,5 @@
+"""Logging configuration.
+"""
 import logging
 
 logger: logging.Logger

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

@@ -1,3 +1,5 @@
+"""Event loop mixins.
+"""
 import sys
 import threading
 from typing_extensions import Never

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

@@ -1,3 +1,8 @@
+"""Event loop using a proactor and related classes.
+
+A proactor is a "notify-on-completion" multiplexer.  Currently a
+proactor is only implemented on Windows with IOCP.
+"""
 import sys
 from collections.abc import Mapping
 from socket import socket
@@ -8,6 +13,8 @@ from . import base_events, constants, events, futures, streams, transports
 __all__ = ("BaseProactorEventLoop",)
 
 class _ProactorBasePipeTransport(transports._FlowControlMixin, transports.BaseTransport):
+    """Base class for pipe and socket transports.
+"""
     def __init__(
         self,
         loop: events.AbstractEventLoop,
@@ -20,6 +27,8 @@ class _ProactorBasePipeTransport(transports._FlowControlMixin, transports.BaseTr
     def __del__(self) -> None: ...
 
 class _ProactorReadPipeTransport(_ProactorBasePipeTransport, transports.ReadTransport):
+    """Transport for read pipes.
+"""
     if sys.version_info >= (3, 10):
         def __init__(
             self,
@@ -42,11 +51,17 @@ class _ProactorReadPipeTransport(_ProactorBasePipeTransport, transports.ReadTran
             server: events.AbstractServer | None = None,
         ) -> None: ...
 
-class _ProactorBaseWritePipeTransport(_ProactorBasePipeTransport, transports.WriteTransport): ...
+class _ProactorBaseWritePipeTransport(_ProactorBasePipeTransport, transports.WriteTransport):
+    """Transport for write pipes.
+"""
 class _ProactorWritePipeTransport(_ProactorBaseWritePipeTransport): ...
-class _ProactorDuplexPipeTransport(_ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport): ...
+class _ProactorDuplexPipeTransport(_ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport):
+    """Transport for duplex pipes.
+"""
 
 class _ProactorSocketTransport(_ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport):
+    """Transport for connected sockets.
+"""
     _sendfile_compatible: ClassVar[constants._SendfileMode]
     def __init__(
         self,

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

@@ -1,3 +1,5 @@
+"""Abstract Protocol base classes.
+"""
 from _typeshed import ReadableBuffer
 from asyncio import transports
 from typing import Any
@@ -6,36 +8,184 @@ from typing import Any
 __all__ = ("BaseProtocol", "Protocol", "DatagramProtocol", "SubprocessProtocol", "BufferedProtocol")
 
 class BaseProtocol:
+    """Common base class for protocol interfaces.
+
+Usually user implements protocols that derived from BaseProtocol
+like Protocol or ProcessProtocol.
+
+The only case when BaseProtocol should be implemented directly is
+write-only transport like write pipe
+"""
     __slots__ = ()
-    def connection_made(self, transport: transports.BaseTransport) -> None: ...
+    def connection_made(self, transport: transports.BaseTransport) -> None:
-    def connection_lost(self, exc: Exception | None) -> None: ...
+        """Called when a connection is made.
-    def pause_writing(self) -> None: ...
+
-    def resume_writing(self) -> None: ...
+The argument is the transport representing the pipe connection.
+To receive data, wait for data_received() calls.
+When the connection is closed, connection_lost() is called.
+"""
+    def connection_lost(self, exc: Exception | None) -> None:
+        """Called when the connection is lost or closed.
+
+The argument is an exception object or None (the latter
+meaning a regular EOF is received or the connection was
+aborted or closed).
+"""
+    def pause_writing(self) -> None:
+        """Called when the transport's buffer goes over the high-water mark.
+
+Pause and resume calls are paired -- pause_writing() is called
+once when the buffer goes strictly over the high-water mark
+(even if subsequent writes increases the buffer size even
+more), and eventually resume_writing() is called once when the
+buffer size reaches the low-water mark.
+
+Note that if the buffer size equals the high-water mark,
+pause_writing() is not called -- it must go strictly over.
+Conversely, resume_writing() is called when the buffer size is
+equal or lower than the low-water mark.  These end conditions
+are important to ensure that things go as expected when either
+mark is zero.
+
+NOTE: This is the only Protocol callback that is not called
+through EventLoop.call_soon() -- if it were, it would have no
+effect when it's most needed (when the app keeps writing
+without yielding until pause_writing() is called).
+"""
+    def resume_writing(self) -> None:
+        """Called when the transport's buffer drains below the low-water mark.
+
+See pause_writing() for details.
+"""
 
 class Protocol(BaseProtocol):
+    """Interface for stream protocol.
+
+The user should implement this interface.  They can inherit from
+this class but don't need to.  The implementations here do
+nothing (they don't raise exceptions).
+
+When the user wants to requests a transport, they pass a protocol
+factory to a utility function (e.g., EventLoop.create_connection()).
+
+When the connection is made successfully, connection_made() is
+called with a suitable transport object.  Then data_received()
+will be called 0 or more times with data (bytes) received from the
+transport; finally, connection_lost() will be called exactly once
+with either an exception object or None as an argument.
+
+State machine of calls:
+
+  start -> CM [-> DR*] [-> ER?] -> CL -> end
+
+* CM: connection_made()
+* DR: data_received()
+* ER: eof_received()
+* CL: connection_lost()
+"""
     # Need annotation or mypy will complain about 'Cannot determine type of "__slots__" in base class'
     __slots__: tuple[str, ...] = ()
-    def data_received(self, data: bytes) -> None: ...
+    def data_received(self, data: bytes) -> None:
-    def eof_received(self) -> bool | None: ...
+        """Called when some data is received.
+
+The argument is a bytes object.
+"""
+    def eof_received(self) -> bool | None:
+        """Called when the other end calls write_eof() or equivalent.
+
+If this returns a false value (including None), the transport
+will close itself.  If it returns a true value, closing the
+transport is up to the protocol.
+"""
 
 class BufferedProtocol(BaseProtocol):
+    """Interface for stream protocol with manual buffer control.
+
+Event methods, such as `create_server` and `create_connection`,
+accept factories that return protocols that implement this interface.
+
+The idea of BufferedProtocol is that it allows to manually allocate
+and control the receive buffer.  Event loops can then use the buffer
+provided by the protocol to avoid unnecessary data copies.  This
+can result in noticeable performance improvement for protocols that
+receive big amounts of data.  Sophisticated protocols can allocate
+the buffer only once at creation time.
+
+State machine of calls:
+
+  start -> CM [-> GB [-> BU?]]* [-> ER?] -> CL -> end
+
+* CM: connection_made()
+* GB: get_buffer()
+* BU: buffer_updated()
+* ER: eof_received()
+* CL: connection_lost()
+"""
     __slots__ = ()
-    def get_buffer(self, sizehint: int) -> ReadableBuffer: ...
+    def get_buffer(self, sizehint: int) -> ReadableBuffer:
-    def buffer_updated(self, nbytes: int) -> None: ...
+        """Called to allocate a new receive buffer.
-    def eof_received(self) -> bool | None: ...
+
+*sizehint* is a recommended minimal size for the returned
+buffer.  When set to -1, the buffer size can be arbitrary.
+
+Must return an object that implements the
+:ref:`buffer protocol <bufferobjects>`.
+It is an error to return a zero-sized buffer.
+"""
+    def buffer_updated(self, nbytes: int) -> None:
+        """Called when the buffer was updated with the received data.
+
+*nbytes* is the total number of bytes that were written to
+the buffer.
+"""
+    def eof_received(self) -> bool | None:
+        """Called when the other end calls write_eof() or equivalent.
+
+If this returns a false value (including None), the transport
+will close itself.  If it returns a true value, closing the
+transport is up to the protocol.
+"""
 
 class DatagramProtocol(BaseProtocol):
+    """Interface for datagram protocol.
+"""
     __slots__ = ()
-    def connection_made(self, transport: transports.DatagramTransport) -> None: ...  # type: ignore[override]
+    def connection_made(self, transport: transports.DatagramTransport) -> None:  # type: ignore[override]
+        """Called when a connection is made.
+
+The argument is the transport representing the pipe connection.
+To receive data, wait for data_received() calls.
+When the connection is closed, connection_lost() is called.
+"""
     # addr can be a tuple[int, int] for some unusual protocols like socket.AF_NETLINK.
     # Use tuple[str | Any, int] to not cause typechecking issues on most usual cases.
     # This could be improved by using tuple[AnyOf[str, int], int] if the AnyOf feature is accepted.
     # See https://github.com/python/typing/issues/566
-    def datagram_received(self, data: bytes, addr: tuple[str | Any, int]) -> None: ...
+    def datagram_received(self, data: bytes, addr: tuple[str | Any, int]) -> None:
-    def error_received(self, exc: Exception) -> None: ...
+        """Called when some datagram is received.
+"""
+    def error_received(self, exc: Exception) -> None:
+        """Called when a send or receive operation raises an OSError.
+
+(Other than BlockingIOError or InterruptedError.)
+"""
 
 class SubprocessProtocol(BaseProtocol):
+    """Interface for protocol for subprocess calls.
+"""
     __slots__: tuple[str, ...] = ()
-    def pipe_data_received(self, fd: int, data: bytes) -> None: ...
+    def pipe_data_received(self, fd: int, data: bytes) -> None:
-    def pipe_connection_lost(self, fd: int, exc: Exception | None) -> None: ...
+        """Called when the subprocess writes data into stdout/stderr pipe.
-    def process_exited(self) -> None: ...
+
+fd is int file descriptor.
+data is bytes object.
+"""
+    def pipe_connection_lost(self, fd: int, exc: Exception | None) -> None:
+        """Called when a file descriptor associated with the child process is
+closed.
+
+fd is the int file descriptor that was closed.
+"""
+    def process_exited(self) -> None:
+        """Called when subprocess has exited.
+"""

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

@@ -9,8 +9,12 @@ if sys.version_info >= (3, 10):
 else:
     _LoopBoundMixin = object
 
-class QueueEmpty(Exception): ...
+class QueueEmpty(Exception):
-class QueueFull(Exception): ...
+    """Raised when Queue.get_nowait() is called on an empty Queue.
+"""
+class QueueFull(Exception):
+    """Raised when the Queue.put_nowait() method is called on a full Queue.
+"""
 
 # Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.version_info >= (3, 13):
@@ -22,11 +26,23 @@ else:
 _T = TypeVar("_T")
 
 if sys.version_info >= (3, 13):
-    class QueueShutDown(Exception): ...
+    class QueueShutDown(Exception):
+        """Raised when putting on to or getting from a shut-down Queue.
+"""
 
 # If Generic[_T] is last and _LoopBoundMixin is object, pyright is unhappy.
 # We can remove the noqa pragma when dropping 3.9 support.
 class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
+    """A queue, useful for coordinating producer and consumer coroutines.
+
+If maxsize is less than or equal to zero, the queue size is infinite. If it
+is an integer greater than 0, then "await put()" will block when the
+queue reaches maxsize, until an item is removed by get().
+
+Unlike the standard library Queue, you can reliably know this Queue's size
+with qsize(), since your single-threaded asyncio application won't be
+interrupted between calling qsize() and doing an operation on the Queue.
+"""
     if sys.version_info >= (3, 10):
         def __init__(self, maxsize: int = 0) -> None: ...
     else:
@@ -36,20 +52,99 @@ class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
     def _get(self) -> _T: ...
     def _put(self, item: _T) -> None: ...
     def _format(self) -> str: ...
-    def qsize(self) -> int: ...
+    def qsize(self) -> int:
+        """Number of items in the queue.
+"""
     @property
-    def maxsize(self) -> int: ...
+    def maxsize(self) -> int:
-    def empty(self) -> bool: ...
+        """Number of items allowed in the queue.
-    def full(self) -> bool: ...
+"""
-    async def put(self, item: _T) -> None: ...
+    def empty(self) -> bool:
-    def put_nowait(self, item: _T) -> None: ...
+        """Return True if the queue is empty, False otherwise.
-    async def get(self) -> _T: ...
+"""
-    def get_nowait(self) -> _T: ...
+    def full(self) -> bool:
-    async def join(self) -> None: ...
+        """Return True if there are maxsize items in the queue.
-    def task_done(self) -> None: ...
-    def __class_getitem__(cls, type: Any, /) -> GenericAlias: ...
-    if sys.version_info >= (3, 13):
-        def shutdown(self, immediate: bool = False) -> None: ...
 
-class PriorityQueue(Queue[SupportsRichComparisonT]): ...
+Note: if the Queue was initialized with maxsize=0 (the default),
-class LifoQueue(Queue[_T]): ...
+then full() is never True.
+"""
+    async def put(self, item: _T) -> None:
+        """Put an item into the queue.
+
+Put an item into the queue. If the queue is full, wait until a free
+slot is available before adding item.
+
+Raises QueueShutDown if the queue has been shut down.
+"""
+    def put_nowait(self, item: _T) -> None:
+        """Put an item into the queue without blocking.
+
+If no free slot is immediately available, raise QueueFull.
+
+Raises QueueShutDown if the queue has been shut down.
+"""
+    async def get(self) -> _T:
+        """Remove and return an item from the queue.
+
+If queue is empty, wait until an item is available.
+
+Raises QueueShutDown if the queue has been shut down and is empty, or
+if the queue has been shut down immediately.
+"""
+    def get_nowait(self) -> _T:
+        """Remove and return an item from the queue.
+
+Return an item if one is immediately available, else raise QueueEmpty.
+
+Raises QueueShutDown if the queue has been shut down and is empty, or
+if the queue has been shut down immediately.
+"""
+    async def join(self) -> None:
+        """Block until all items in the queue have been gotten and processed.
+
+The count of unfinished tasks goes up whenever an item is added to the
+queue. The count goes down whenever a consumer calls task_done() to
+indicate that the item was retrieved and all work on it is complete.
+When the count of unfinished tasks drops to zero, join() unblocks.
+"""
+    def task_done(self) -> None:
+        """Indicate that a formerly enqueued task is complete.
+
+Used by queue consumers. For each get() used to fetch a task,
+a subsequent call to task_done() tells the queue that the processing
+on the task is complete.
+
+If a join() is currently blocking, it will resume when all items have
+been processed (meaning that a task_done() call was received for every
+item that had been put() into the queue).
+
+Raises ValueError if called more times than there were items placed in
+the queue.
+"""
+    def __class_getitem__(cls, type: Any, /) -> GenericAlias:
+        """Represent a PEP 585 generic type
+
+E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+"""
+    if sys.version_info >= (3, 13):
+        def shutdown(self, immediate: bool = False) -> None:
+            """Shut-down the queue, making queue gets and puts raise QueueShutDown.
+
+By default, gets will only raise once the queue is empty. Set
+'immediate' to True to make gets raise immediately instead.
+
+All blocked callers of put() and get() will be unblocked.
+
+If 'immediate', the queue is drained and unfinished tasks
+is reduced by the number of drained tasks.  If unfinished tasks
+is reduced to zero, callers of Queue.join are unblocked.
+"""
+
+class PriorityQueue(Queue[SupportsRichComparisonT]):
+    """A subclass of Queue; retrieves entries in priority order (lowest first).
+
+Entries are typically tuples of the form: (priority number, data).
+"""
+class LifoQueue(Queue[_T]):
+    """A subclass of Queue that retrieves most recently added entries first.
+"""

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

@@ -17,20 +17,103 @@ _T = TypeVar("_T")
 if sys.version_info >= (3, 11):
     @final
     class Runner:
+        """A context manager that controls event loop life cycle.
+
+The context manager always creates a new event loop,
+allows to run async functions inside it,
+and properly finalizes the loop at the context manager exit.
+
+If debug is True, the event loop will be run in debug mode.
+If loop_factory is passed, it is used for new event loop creation.
+
+asyncio.run(main(), debug=True)
+
+is a shortcut for
+
+with asyncio.Runner(debug=True) as runner:
+    runner.run(main())
+
+The run() method can be called multiple times within the runner's context.
+
+This can be useful for interactive console (e.g. IPython),
+unittest runners, console tools, -- everywhere when async code
+is called from existing sync framework and where the preferred single
+asyncio.run() call doesn't work.
+
+"""
         def __init__(self, *, debug: bool | None = None, loop_factory: Callable[[], AbstractEventLoop] | None = None) -> None: ...
         def __enter__(self) -> Self: ...
         def __exit__(self, exc_type: Unused, exc_val: Unused, exc_tb: Unused) -> None: ...
-        def close(self) -> None: ...
+        def close(self) -> None:
-        def get_loop(self) -> AbstractEventLoop: ...
+            """Shutdown and close event loop.
+"""
+        def get_loop(self) -> AbstractEventLoop:
+            """Return embedded event loop.
+"""
         if sys.version_info >= (3, 14):
-            def run(self, coro: Awaitable[_T], *, context: Context | None = None) -> _T: ...
+            def run(self, coro: Awaitable[_T], *, context: Context | None = None) -> _T:
+                """Run code in the embedded event loop.
+"""
         else:
-            def run(self, coro: Coroutine[Any, Any, _T], *, context: Context | None = None) -> _T: ...
+            def run(self, coro: Coroutine[Any, Any, _T], *, context: Context | None = None) -> _T:
+                """Run a coroutine inside the embedded event loop.
+"""
 
 if sys.version_info >= (3, 12):
     def run(
         main: Coroutine[Any, Any, _T], *, debug: bool | None = None, loop_factory: Callable[[], AbstractEventLoop] | None = None
-    ) -> _T: ...
+    ) -> _T:
+        """Execute the coroutine and return the result.
+
+This function runs the passed coroutine, taking care of
+managing the asyncio event loop, finalizing asynchronous
+generators and closing the default executor.
+
+This function cannot be called when another asyncio event loop is
+running in the same thread.
+
+If debug is True, the event loop will be run in debug mode.
+If loop_factory is passed, it is used for new event loop creation.
+
+This function always creates a new event loop and closes it at the end.
+It should be used as a main entry point for asyncio programs, and should
+ideally only be called once.
+
+The executor is given a timeout duration of 5 minutes to shutdown.
+If the executor hasn't finished within that duration, a warning is
+emitted and the executor is closed.
+
+Example:
+
+    async def main():
+        await asyncio.sleep(1)
+        print('hello')
+
+    asyncio.run(main())
+"""
 
 else:
-    def run(main: Coroutine[Any, Any, _T], *, debug: bool | None = None) -> _T: ...
+    def run(main: Coroutine[Any, Any, _T], *, debug: bool | None = None) -> _T:
+        """Execute the coroutine and return the result.
+
+    This function runs the passed coroutine, taking care of
+    managing the asyncio event loop and finalizing asynchronous
+    generators.
+
+    This function cannot be called when another asyncio event loop is
+    running in the same thread.
+
+    If debug is True, the event loop will be run in debug mode.
+
+    This function always creates a new event loop and closes it at the end.
+    It should be used as a main entry point for asyncio programs, and should
+    ideally only be called once.
+
+    Example:
+
+        async def main():
+            await asyncio.sleep(1)
+            print('hello')
+
+        asyncio.run(main())
+    """

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

@@ -1,3 +1,8 @@
+"""Event loop using a selector and related classes.
+
+A selector is a "notify-when-ready" multiplexer.  For a subclass which
+also includes support for signal handling, see the unix_events sub-module.
+"""
 import selectors
 from socket import socket
 
@@ -6,5 +11,15 @@ from . import base_events
 __all__ = ("BaseSelectorEventLoop",)
 
 class BaseSelectorEventLoop(base_events.BaseEventLoop):
+    """Selector event loop.
+
+See events.EventLoop for API specification.
+"""
     def __init__(self, selector: selectors.BaseSelector | None = None) -> None: ...
-    async def sock_recv(self, sock: socket, n: int) -> bytes: ...
+    async def sock_recv(self, sock: socket, n: int) -> bytes:
+        """Receive data from the socket.
+
+The return value is a bytes object representing the data received.
+The maximum amount of data to be received at once is specified by
+nbytes.
+"""

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

@@ -36,6 +36,22 @@ else:
 
 if sys.version_info < (3, 11):
     class _SSLPipe:
+        """An SSL "Pipe".
+
+    An SSL pipe allows you to communicate with an SSL/TLS protocol instance
+    through memory buffers. It can be used to implement a security layer for an
+    existing connection where you don't have access to the connection's file
+    descriptor, or for some reason you don't want to use it.
+
+    An SSL pipe can be in "wrapped" and "unwrapped" mode. In unwrapped mode,
+    data is passed through untransformed. In wrapped mode, application level
+    data is encrypted to SSL record level data and vice versa. The SSL record
+    level is the lowest level in the SSL protocol suite and is what travels
+    as-is over the wire.
+
+    An SslPipe initially is in "unwrapped" mode. To start SSL, call
+    do_handshake(). To shutdown SSL again, call unwrap().
+    """
         max_size: ClassVar[int]
 
         _context: ssl.SSLContext
@@ -48,20 +64,93 @@ if sys.version_info < (3, 11):
         _need_ssldata: bool
         _handshake_cb: Callable[[BaseException | None], None] | None
         _shutdown_cb: Callable[[], None] | None
-        def __init__(self, context: ssl.SSLContext, server_side: bool, server_hostname: str | None = None) -> None: ...
+        def __init__(self, context: ssl.SSLContext, server_side: bool, server_hostname: str | None = None) -> None:
+            """
+        The *context* argument specifies the ssl.SSLContext to use.
+
+        The *server_side* argument indicates whether this is a server side or
+        client side transport.
+
+        The optional *server_hostname* argument can be used to specify the
+        hostname you are connecting to. You may only specify this parameter if
+        the _ssl module supports Server Name Indication (SNI).
+        """
         @property
-        def context(self) -> ssl.SSLContext: ...
+        def context(self) -> ssl.SSLContext:
+            """The SSL context passed to the constructor.
+"""
         @property
-        def ssl_object(self) -> ssl.SSLObject | None: ...
+        def ssl_object(self) -> ssl.SSLObject | None:
+            """The internal ssl.SSLObject instance.
+
+        Return None if the pipe is not wrapped.
+        """
         @property
-        def need_ssldata(self) -> bool: ...
+        def need_ssldata(self) -> bool:
+            """Whether more record level data is needed to complete a handshake
+        that is currently in progress.
+"""
         @property
-        def wrapped(self) -> bool: ...
+        def wrapped(self) -> bool:
-        def do_handshake(self, callback: Callable[[BaseException | None], object] | None = None) -> list[bytes]: ...
+            """
-        def shutdown(self, callback: Callable[[], object] | None = None) -> list[bytes]: ...
+        Whether a security layer is currently in effect.
-        def feed_eof(self) -> None: ...
+
-        def feed_ssldata(self, data: bytes, only_handshake: bool = False) -> tuple[list[bytes], list[bytes]]: ...
+        Return False during handshake.
-        def feed_appdata(self, data: bytes, offset: int = 0) -> tuple[list[bytes], int]: ...
+        """
+        def do_handshake(self, callback: Callable[[BaseException | None], object] | None = None) -> list[bytes]:
+            """Start the SSL handshake.
+
+        Return a list of ssldata. A ssldata element is a list of buffers
+
+        The optional *callback* argument can be used to install a callback that
+        will be called when the handshake is complete. The callback will be
+        called with None if successful, else an exception instance.
+        """
+        def shutdown(self, callback: Callable[[], object] | None = None) -> list[bytes]:
+            """Start the SSL shutdown sequence.
+
+        Return a list of ssldata. A ssldata element is a list of buffers
+
+        The optional *callback* argument can be used to install a callback that
+        will be called when the shutdown is complete. The callback will be
+        called without arguments.
+        """
+        def feed_eof(self) -> None:
+            """Send a potentially "ragged" EOF.
+
+        This method will raise an SSL_ERROR_EOF exception if the EOF is
+        unexpected.
+        """
+        def feed_ssldata(self, data: bytes, only_handshake: bool = False) -> tuple[list[bytes], list[bytes]]:
+            """Feed SSL record level data into the pipe.
+
+        The data must be a bytes instance. It is OK to send an empty bytes
+        instance. This can be used to get ssldata for a handshake initiated by
+        this endpoint.
+
+        Return a (ssldata, appdata) tuple. The ssldata element is a list of
+        buffers containing SSL data that needs to be sent to the remote SSL.
+
+        The appdata element is a list of buffers containing plaintext data that
+        needs to be forwarded to the application. The appdata list may contain
+        an empty buffer indicating an SSL "close_notify" alert. This alert must
+        be acknowledged by calling shutdown().
+        """
+        def feed_appdata(self, data: bytes, offset: int = 0) -> tuple[list[bytes], int]:
+            """Feed plaintext data into the pipe.
+
+        Return an (ssldata, offset) tuple. The ssldata element is a list of
+        buffers containing record level data that needs to be sent to the
+        remote SSL instance. The offset is the number of plaintext bytes that
+        were processed, which may be less than the length of data.
+
+        NOTE: In case of short writes, this call MUST be retried with the SAME
+        buffer passed into the *data* argument (i.e. the id() must be the
+        same). This is an OpenSSL requirement. A further particularity is that
+        a short write will always have offset == 0, because the _ssl module
+        does not enable partial writes. And even though the offset is zero,
+        there will still be encrypted data in ssldata.
+        """
 
 class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport):
     _sendfile_compatible: ClassVar[constants._SendfileMode]
@@ -73,16 +162,45 @@ class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport):
         _ssl_protocol: SSLProtocol
     _closed: bool
     def __init__(self, loop: events.AbstractEventLoop, ssl_protocol: SSLProtocol) -> None: ...
-    def get_extra_info(self, name: str, default: Any | None = None) -> dict[str, Any]: ...
+    def get_extra_info(self, name: str, default: Any | None = None) -> dict[str, Any]:
+        """Get optional transport information.
+"""
     @property
     def _protocol_paused(self) -> bool: ...
-    def write(self, data: bytes | bytearray | memoryview[Any]) -> None: ...  # any memoryview format or shape
+    def write(self, data: bytes | bytearray | memoryview[Any]) -> None:  # any memoryview format or shape
-    def can_write_eof(self) -> Literal[False]: ...
+        """Write some data bytes to the transport.
+
+This does not block; it buffers the data and arranges for it
+to be sent out asynchronously.
+"""
+    def can_write_eof(self) -> Literal[False]:
+        """Return True if this transport supports write_eof(), False if not.
+"""
     if sys.version_info >= (3, 11):
         def get_write_buffer_limits(self) -> tuple[int, int]: ...
         def get_read_buffer_limits(self) -> tuple[int, int]: ...
-        def set_read_buffer_limits(self, high: int | None = None, low: int | None = None) -> None: ...
+        def set_read_buffer_limits(self, high: int | None = None, low: int | None = None) -> None:
-        def get_read_buffer_size(self) -> int: ...
+            """Set the high- and low-water limits for read flow control.
+
+These two values control when to call the upstream transport's
+pause_reading() and resume_reading() methods.  If specified,
+the low-water limit must be less than or equal to the
+high-water limit.  Neither value can be negative.
+
+The defaults are implementation-specific.  If only the
+high-water limit is given, the low-water limit defaults to an
+implementation-specific value less than or equal to the
+high-water limit.  Setting high to zero forces low to zero as
+well, and causes pause_reading() to be called whenever the
+buffer becomes non-empty.  Setting low to zero causes
+resume_reading() to be called only once the buffer is empty.
+Use of zero for either limit is generally sub-optimal as it
+reduces opportunities for doing I/O and computation
+concurrently.
+"""
+        def get_read_buffer_size(self) -> int:
+            """Return the current size of the read buffer.
+"""
 
     def __del__(self) -> None: ...
 
@@ -92,6 +210,11 @@ else:
     _SSLProtocolBase: TypeAlias = protocols.Protocol
 
 class SSLProtocol(_SSLProtocolBase):
+    """SSL protocol.
+
+    Implementation of SSL on top of a socket using incoming and outgoing
+    buffers which are ssl.MemoryBIO objects.
+    """
     _server_side: bool
     _server_hostname: str | None
     _sslcontext: ssl.SSLContext
@@ -143,8 +266,21 @@ class SSLProtocol(_SSLProtocolBase):
 
     def _set_app_protocol(self, app_protocol: protocols.BaseProtocol) -> None: ...
     def _wakeup_waiter(self, exc: BaseException | None = None) -> None: ...
-    def connection_lost(self, exc: BaseException | None) -> None: ...
+    def connection_lost(self, exc: BaseException | None) -> None:
-    def eof_received(self) -> None: ...
+        """Called when the low-level connection is lost or closed.
+
+The argument is an exception object or None (the latter
+meaning a regular EOF is received or the connection was
+aborted or closed).
+"""
+    def eof_received(self) -> None:
+        """Called when the other end of the low-level stream
+is half-closed.
+
+If this returns a false value (including None), the transport
+will close itself.  If it returns a true value, closing the
+transport is up to the protocol.
+"""
     def _get_extra_info(self, name: str, default: Any | None = None) -> Any: ...
     def _start_shutdown(self) -> None: ...
     if sys.version_info >= (3, 11):

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

@@ -1,3 +1,5 @@
+"""Support for running coroutines in parallel with staggered start times.
+"""
 from collections.abc import Awaitable, Callable, Iterable
 from typing import Any
 
@@ -7,4 +9,54 @@ __all__ = ("staggered_race",)
 
 async def staggered_race(
     coro_fns: Iterable[Callable[[], Awaitable[Any]]], delay: float | None, *, loop: events.AbstractEventLoop | None = None
-) -> tuple[Any, int | None, list[Exception | None]]: ...
+) -> tuple[Any, int | None, list[Exception | None]]:
+    """Run coroutines with staggered start times and take the first to finish.
+
+This method takes an iterable of coroutine functions. The first one is
+started immediately. From then on, whenever the immediately preceding one
+fails (raises an exception), or when *delay* seconds has passed, the next
+coroutine is started. This continues until one of the coroutines complete
+successfully, in which case all others are cancelled, or until all
+coroutines fail.
+
+The coroutines provided should be well-behaved in the following way:
+
+* They should only ``return`` if completed successfully.
+
+* They should always raise an exception if they did not complete
+  successfully. In particular, if they handle cancellation, they should
+  probably reraise, like this::
+
+    try:
+        # do work
+    except asyncio.CancelledError:
+        # undo partially completed work
+        raise
+
+Args:
+    coro_fns: an iterable of coroutine functions, i.e. callables that
+        return a coroutine object when called. Use ``functools.partial`` or
+        lambdas to pass arguments.
+
+    delay: amount of time, in seconds, between starting coroutines. If
+        ``None``, the coroutines will run sequentially.
+
+    loop: the event loop to use.
+
+Returns:
+    tuple *(winner_result, winner_index, exceptions)* where
+
+    - *winner_result*: the result of the winning coroutine, or ``None``
+      if no coroutines won.
+
+    - *winner_index*: the index of the winning coroutine in
+      ``coro_fns``, or ``None`` if no coroutines won. If the winning
+      coroutine may return None on success, *winner_index* can be used
+      to definitively determine whether any coroutine won.
+
+    - *exceptions*: list of exceptions returned by the coroutines.
+      ``len(exceptions)`` is equal to the number of coroutines actually
+      started, and the order is the same as in ``coro_fns``. The winning
+      coroutine's entry is ``None``.
+
+"""

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

@@ -36,7 +36,24 @@ if sys.version_info >= (3, 10):
         limit: int = 65536,
         ssl_handshake_timeout: float | None = None,
         **kwds: Any,
-    ) -> tuple[StreamReader, StreamWriter]: ...
+    ) -> tuple[StreamReader, StreamWriter]:
+        """A wrapper for create_connection() returning a (reader, writer) pair.
+
+The reader returned is a StreamReader instance; the writer is a
+StreamWriter instance.
+
+The arguments are all the usual arguments to create_connection()
+except protocol_factory; most common are positional host and port,
+with various optional keyword arguments following.
+
+Additional optional keyword arguments are loop (to set the event loop
+instance to use) and limit (to set the buffer limit passed to the
+StreamReader).
+
+(If you want to customize the StreamReader and/or
+StreamReaderProtocol classes, just copy the code -- there's
+really nothing special here except some convenience.)
+"""
     async def start_server(
         client_connected_cb: _ClientConnectedCallback,
         host: str | Sequence[str] | None = None,
@@ -45,7 +62,27 @@ if sys.version_info >= (3, 10):
         limit: int = 65536,
         ssl_handshake_timeout: float | None = None,
         **kwds: Any,
-    ) -> Server: ...
+    ) -> Server:
+        """Start a socket server, call back for each client connected.
+
+The first parameter, `client_connected_cb`, takes two parameters:
+client_reader, client_writer.  client_reader is a StreamReader
+object, while client_writer is a StreamWriter object.  This
+parameter can either be a plain callback function or a coroutine;
+if it is a coroutine, it will be automatically converted into a
+Task.
+
+The rest of the arguments are all the usual arguments to
+loop.create_server() except protocol_factory; most common are
+positional host and port, with various optional keyword arguments
+following.  The return value is the same as loop.create_server().
+
+Additional optional keyword argument is limit (to set the buffer
+limit passed to the StreamReader).
+
+The return value is the same as loop.create_server(), i.e. a
+Server object which can be used to stop the service.
+"""
 
 else:
     async def open_connection(
@@ -56,7 +93,24 @@ else:
         limit: int = 65536,
         ssl_handshake_timeout: float | None = None,
         **kwds: Any,
-    ) -> tuple[StreamReader, StreamWriter]: ...
+    ) -> tuple[StreamReader, StreamWriter]:
+        """A wrapper for create_connection() returning a (reader, writer) pair.
+
+    The reader returned is a StreamReader instance; the writer is a
+    StreamWriter instance.
+
+    The arguments are all the usual arguments to create_connection()
+    except protocol_factory; most common are positional host and port,
+    with various optional keyword arguments following.
+
+    Additional optional keyword arguments are loop (to set the event loop
+    instance to use) and limit (to set the buffer limit passed to the
+    StreamReader).
+
+    (If you want to customize the StreamReader and/or
+    StreamReaderProtocol classes, just copy the code -- there's
+    really nothing special here except some convenience.)
+    """
     async def start_server(
         client_connected_cb: _ClientConnectedCallback,
         host: str | None = None,
@@ -66,20 +120,47 @@ else:
         limit: int = 65536,
         ssl_handshake_timeout: float | None = None,
         **kwds: Any,
-    ) -> Server: ...
+    ) -> Server:
+        """Start a socket server, call back for each client connected.
+
+    The first parameter, `client_connected_cb`, takes two parameters:
+    client_reader, client_writer.  client_reader is a StreamReader
+    object, while client_writer is a StreamWriter object.  This
+    parameter can either be a plain callback function or a coroutine;
+    if it is a coroutine, it will be automatically converted into a
+    Task.
+
+    The rest of the arguments are all the usual arguments to
+    loop.create_server() except protocol_factory; most common are
+    positional host and port, with various optional keyword arguments
+    following.  The return value is the same as loop.create_server().
+
+    Additional optional keyword arguments are loop (to set the event loop
+    instance to use) and limit (to set the buffer limit passed to the
+    StreamReader).
+
+    The return value is the same as loop.create_server(), i.e. a
+    Server object which can be used to stop the service.
+    """
 
 if sys.platform != "win32":
     if sys.version_info >= (3, 10):
         async def open_unix_connection(
             path: StrPath | None = None, *, limit: int = 65536, **kwds: Any
-        ) -> tuple[StreamReader, StreamWriter]: ...
+        ) -> tuple[StreamReader, StreamWriter]:
+            """Similar to `open_connection` but works with UNIX Domain Sockets.
+"""
         async def start_unix_server(
             client_connected_cb: _ClientConnectedCallback, path: StrPath | None = None, *, limit: int = 65536, **kwds: Any
-        ) -> Server: ...
+        ) -> Server:
+            """Similar to `start_server` but works with UNIX Domain Sockets.
+"""
     else:
         async def open_unix_connection(
             path: StrPath | None = None, *, loop: events.AbstractEventLoop | None = None, limit: int = 65536, **kwds: Any
-        ) -> tuple[StreamReader, StreamWriter]: ...
+        ) -> tuple[StreamReader, StreamWriter]:
+            """Similar to `open_connection` but works with UNIX Domain Sockets.
+"""
         async def start_unix_server(
             client_connected_cb: _ClientConnectedCallback,
             path: StrPath | None = None,
@@ -87,12 +168,29 @@ if sys.platform != "win32":
             loop: events.AbstractEventLoop | None = None,
             limit: int = 65536,
             **kwds: Any,
-        ) -> Server: ...
+        ) -> Server:
+            """Similar to `start_server` but works with UNIX Domain Sockets.
+"""
 
 class FlowControlMixin(protocols.Protocol):
+    """Reusable flow control logic for StreamWriter.drain().
+
+This implements the protocol methods pause_writing(),
+resume_writing() and connection_lost().  If the subclass overrides
+these it must call the super methods.
+
+StreamWriter.drain() must wait for _drain_helper() coroutine.
+"""
     def __init__(self, loop: events.AbstractEventLoop | None = None) -> None: ...
 
 class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
+    """Helper class to adapt between Protocol and StreamReader.
+
+(This is a helper class instead of making StreamReader itself a
+Protocol subclass, because the StreamReader has other potential
+uses, and to prevent the user of the StreamReader to accidentally
+call inappropriate methods of the protocol.)
+"""
     def __init__(
         self,
         stream_reader: StreamReader,
@@ -102,6 +200,14 @@ class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
     def __del__(self) -> None: ...
 
 class StreamWriter:
+    """Wraps a Transport.
+
+This exposes write(), writelines(), [can_]write_eof(),
+get_extra_info() and close().  It adds drain() which returns an
+optional Future on which you can wait for flow control.  It also
+adds a transport property which references the Transport
+directly.
+"""
     def __init__(
         self,
         transport: transports.WriteTransport,
@@ -119,7 +225,14 @@ class StreamWriter:
     def is_closing(self) -> bool: ...
     async def wait_closed(self) -> None: ...
     def get_extra_info(self, name: str, default: Any = None) -> Any: ...
-    async def drain(self) -> None: ...
+    async def drain(self) -> None:
+        """Flush the write buffer.
+
+The intended use is to write
+
+  w.write(data)
+  await w.drain()
+"""
     if sys.version_info >= (3, 12):
         async def start_tls(
             self,
@@ -128,11 +241,15 @@ class StreamWriter:
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> None: ...
+        ) -> None:
+            """Upgrade an existing stream-based connection to TLS.
+"""
     elif sys.version_info >= (3, 11):
         async def start_tls(
             self, sslcontext: ssl.SSLContext, *, server_hostname: str | None = None, ssl_handshake_timeout: float | None = None
-        ) -> None: ...
+        ) -> None:
+            """Upgrade an existing stream-based connection to TLS.
+"""
 
     if sys.version_info >= (3, 13):
         def __del__(self, warnings: ModuleType = ...) -> None: ...
@@ -145,15 +262,111 @@ class StreamReader:
     def set_exception(self, exc: Exception) -> None: ...
     def set_transport(self, transport: transports.BaseTransport) -> None: ...
     def feed_eof(self) -> None: ...
-    def at_eof(self) -> bool: ...
+    def at_eof(self) -> bool:
+        """Return True if the buffer is empty and 'feed_eof' was called.
+"""
     def feed_data(self, data: Iterable[SupportsIndex]) -> None: ...
-    async def readline(self) -> bytes: ...
+    async def readline(self) -> bytes:
-    if sys.version_info >= (3, 13):
+        """Read chunk of data from the stream until newline (b'
-        async def readuntil(self, separator: _ReaduntilBuffer | tuple[_ReaduntilBuffer, ...] = b"\n") -> bytes: ...
+') is found.
-    else:
-        async def readuntil(self, separator: _ReaduntilBuffer = b"\n") -> bytes: ...
 
-    async def read(self, n: int = -1) -> bytes: ...
+        On success, return chunk that ends with newline. If only partial
-    async def readexactly(self, n: int) -> bytes: ...
+        line can be read due to EOF, return incomplete line without
+        terminating newline. When EOF was reached while no bytes read, empty
+        bytes object is returned.
+
+        If limit is reached, ValueError will be raised. In that case, if
+        newline was found, complete line including newline will be removed
+        from internal buffer. Else, internal buffer will be cleared. Limit is
+        compared against part of the line without newline.
+
+        If stream was paused, this function will automatically resume it if
+        needed.
+        """
+    if sys.version_info >= (3, 13):
+        async def readuntil(self, separator: _ReaduntilBuffer | tuple[_ReaduntilBuffer, ...] = b"\n") -> bytes:
+            """Read data from the stream until ``separator`` is found.
+
+On success, the data and separator will be removed from the
+internal buffer (consumed). Returned data will include the
+separator at the end.
+
+Configured stream limit is used to check result. Limit sets the
+maximal length of data that can be returned, not counting the
+separator.
+
+If an EOF occurs and the complete separator is still not found,
+an IncompleteReadError exception will be raised, and the internal
+buffer will be reset.  The IncompleteReadError.partial attribute
+may contain the separator partially.
+
+If the data cannot be read because of over limit, a
+LimitOverrunError exception  will be raised, and the data
+will be left in the internal buffer, so it can be read again.
+
+The ``separator`` may also be a tuple of separators. In this
+case the return value will be the shortest possible that has any
+separator as the suffix. For the purposes of LimitOverrunError,
+the shortest possible separator is considered to be the one that
+matched.
+"""
+    else:
+        async def readuntil(self, separator: _ReaduntilBuffer = b"\n") -> bytes:
+            """Read data from the stream until ``separator`` is found.
+
+        On success, the data and separator will be removed from the
+        internal buffer (consumed). Returned data will include the
+        separator at the end.
+
+        Configured stream limit is used to check result. Limit sets the
+        maximal length of data that can be returned, not counting the
+        separator.
+
+        If an EOF occurs and the complete separator is still not found,
+        an IncompleteReadError exception will be raised, and the internal
+        buffer will be reset.  The IncompleteReadError.partial attribute
+        may contain the separator partially.
+
+        If the data cannot be read because of over limit, a
+        LimitOverrunError exception  will be raised, and the data
+        will be left in the internal buffer, so it can be read again.
+        """
+
+    async def read(self, n: int = -1) -> bytes:
+        """Read up to `n` bytes from the stream.
+
+If `n` is not provided or set to -1,
+read until EOF, then return all read bytes.
+If EOF was received and the internal buffer is empty,
+return an empty bytes object.
+
+If `n` is 0, return an empty bytes object immediately.
+
+If `n` is positive, return at most `n` available bytes
+as soon as at least 1 byte is available in the internal buffer.
+If EOF is received before any byte is read, return an empty
+bytes object.
+
+Returned value is not limited with limit, configured at stream
+creation.
+
+If stream was paused, this function will automatically resume it if
+needed.
+"""
+    async def readexactly(self, n: int) -> bytes:
+        """Read exactly `n` bytes.
+
+Raise an IncompleteReadError if EOF is reached before `n` bytes can be
+read. The IncompleteReadError.partial attribute of the exception will
+contain the partial read bytes.
+
+if n is zero, return empty bytes object.
+
+Returned value is not limited with limit, configured at stream
+creation.
+
+If stream was paused, this function will automatically resume it if
+needed.
+"""
     def __aiter__(self) -> Self: ...
     async def __anext__(self) -> bytes: ...

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

@@ -13,6 +13,8 @@ STDOUT: int
 DEVNULL: int
 
 class SubprocessStreamProtocol(streams.FlowControlMixin, protocols.SubprocessProtocol):
+    """Like StreamReaderProtocol, but for a subprocess.
+"""
     stdin: streams.StreamWriter | None
     stdout: streams.StreamReader | None
     stderr: streams.StreamReader | None
@@ -29,7 +31,9 @@ class Process:
     ) -> None: ...
     @property
     def returncode(self) -> int | None: ...
-    async def wait(self) -> int: ...
+    async def wait(self) -> int:
+        """Wait until the process exit and return the process return code.
+"""
     def send_signal(self, signal: int) -> None: ...
     def terminate(self) -> None: ...
     def kill(self) -> None: ...

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

@@ -17,10 +17,29 @@ else:
 _T = TypeVar("_T")
 
 class TaskGroup:
+    """Asynchronous context manager for managing groups of tasks.
+
+Example use:
+
+    async with asyncio.TaskGroup() as group:
+        task1 = group.create_task(some_coroutine(...))
+        task2 = group.create_task(other_coroutine(...))
+    print("Both tasks have completed now.")
+
+All tasks are awaited when the context manager exits.
+
+Any exceptions other than `asyncio.CancelledError` raised within
+a task will cancel all remaining tasks and wait for them to exit.
+The exceptions are then combined and raised as an `ExceptionGroup`.
+"""
     _loop: AbstractEventLoop | None
     _tasks: set[Task[Any]]
 
     async def __aenter__(self) -> Self: ...
     async def __aexit__(self, et: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> None: ...
-    def create_task(self, coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]: ...
+    def create_task(self, coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]:
+        """Create a new task in this group and return it.
+
+Similar to `asyncio.create_task`.
+"""
     def _on_task_done(self, task: Task[object]) -> None: ...

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

@@ -1,3 +1,5 @@
+"""Support for tasks, coroutines and the scheduler.
+"""
 import concurrent.futures
 import sys
 from _asyncio import (
@@ -90,18 +92,101 @@ if sys.version_info >= (3, 13):
     @type_check_only
     class _SyncAndAsyncIterator(Iterator[_T_co], AsyncIterator[_T_co], Protocol[_T_co]): ...
 
-    def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> _SyncAndAsyncIterator[Future[_T]]: ...
+    def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> _SyncAndAsyncIterator[Future[_T]]:
+        """Create an iterator of awaitables or their results in completion order.
+
+Run the supplied awaitables concurrently. The returned object can be
+iterated to obtain the results of the awaitables as they finish.
+
+The object returned can be iterated as an asynchronous iterator or a plain
+iterator. When asynchronous iteration is used, the originally-supplied
+awaitables are yielded if they are tasks or futures. This makes it easy to
+correlate previously-scheduled tasks with their results:
+
+    ipv4_connect = create_task(open_connection("127.0.0.1", 80))
+    ipv6_connect = create_task(open_connection("::1", 80))
+    tasks = [ipv4_connect, ipv6_connect]
+
+    async for earliest_connect in as_completed(tasks):
+        # earliest_connect is done. The result can be obtained by
+        # awaiting it or calling earliest_connect.result()
+        reader, writer = await earliest_connect
+
+        if earliest_connect is ipv6_connect:
+            print("IPv6 connection established.")
+        else:
+            print("IPv4 connection established.")
+
+During asynchronous iteration, implicitly-created tasks will be yielded for
+supplied awaitables that aren't tasks or futures.
+
+When used as a plain iterator, each iteration yields a new coroutine that
+returns the result or raises the exception of the next completed awaitable.
+This pattern is compatible with Python versions older than 3.13:
+
+    ipv4_connect = create_task(open_connection("127.0.0.1", 80))
+    ipv6_connect = create_task(open_connection("::1", 80))
+    tasks = [ipv4_connect, ipv6_connect]
+
+    for next_connect in as_completed(tasks):
+        # next_connect is not one of the original task objects. It must be
+        # awaited to obtain the result value or raise the exception of the
+        # awaitable that finishes next.
+        reader, writer = await next_connect
+
+A TimeoutError is raised if the timeout occurs before all awaitables are
+done. This is raised by the async for loop during asynchronous iteration or
+by the coroutines yielded during plain iteration.
+"""
 
 elif sys.version_info >= (3, 10):
-    def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> Iterator[Future[_T]]: ...
+    def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> Iterator[Future[_T]]:
+        """Return an iterator whose values are coroutines.
+
+    When waiting for the yielded coroutines you'll get the results (or
+    exceptions!) of the original Futures (or coroutines), in the order
+    in which and as soon as they complete.
+
+    This differs from PEP 3148; the proper way to use this is:
+
+        for f in as_completed(fs):
+            result = await f  # The 'await' may raise.
+            # Use result.
+
+    If a timeout is specified, the 'await' will raise
+    TimeoutError when the timeout occurs before all Futures are done.
+
+    Note: The futures 'f' are not necessarily members of fs.
+    """
 
 else:
     def as_completed(
         fs: Iterable[_FutureLike[_T]], *, loop: AbstractEventLoop | None = None, timeout: float | None = None
-    ) -> Iterator[Future[_T]]: ...
+    ) -> Iterator[Future[_T]]:
+        """Return an iterator whose values are coroutines.
+
+    When waiting for the yielded coroutines you'll get the results (or
+    exceptions!) of the original Futures (or coroutines), in the order
+    in which and as soon as they complete.
+
+    This differs from PEP 3148; the proper way to use this is:
+
+        for f in as_completed(fs):
+            result = await f  # The 'await' may raise.
+            # Use result.
+
+    If a timeout is specified, the 'await' will raise
+    TimeoutError when the timeout occurs before all Futures are done.
+
+    Note: The futures 'f' are not necessarily members of fs.
+    """
 
 @overload
-def ensure_future(coro_or_future: _FT, *, loop: AbstractEventLoop | None = None) -> _FT: ...  # type: ignore[overload-overlap]
+def ensure_future(coro_or_future: _FT, *, loop: AbstractEventLoop | None = None) -> _FT:  # type: ignore[overload-overlap]
+    """Wrap a coroutine or an awaitable in a future.
+
+If the argument is a Future, it is returned directly.
+"""
 @overload
 def ensure_future(coro_or_future: Awaitable[_T], *, loop: AbstractEventLoop | None = None) -> Task[_T]: ...
 
@@ -113,7 +198,36 @@ def ensure_future(coro_or_future: Awaitable[_T], *, loop: AbstractEventLoop | No
 # N.B. Having overlapping overloads is the only way to get acceptable type inference in all edge cases.
 if sys.version_info >= (3, 10):
     @overload
-    def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: Literal[False] = False) -> Future[tuple[_T1]]: ...  # type: ignore[overload-overlap]
+    def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: Literal[False] = False) -> Future[tuple[_T1]]:  # type: ignore[overload-overlap]
+        """Return a future aggregating results from the given coroutines/futures.
+
+Coroutines will be wrapped in a future and scheduled in the event
+loop. They will not necessarily be scheduled in the same order as
+passed in.
+
+All futures must share the same event loop.  If all the tasks are
+done successfully, the returned future's result is the list of
+results (in the order of the original sequence, not necessarily
+the order of results arrival).  If *return_exceptions* is True,
+exceptions in the tasks are treated the same as successful
+results, and gathered in the result list; otherwise, the first
+raised exception will be immediately propagated to the returned
+future.
+
+Cancellation: if the outer Future is cancelled, all children (that
+have not completed yet) are also cancelled.  If any child is
+cancelled, this is treated as if it raised CancelledError --
+the outer Future is *not* cancelled in this case.  (This is to
+prevent the cancellation of one child to cause other children to
+be cancelled.)
+
+If *return_exceptions* is False, cancelling gather() after it
+has been marked done won't cancel any submitted awaitables.
+For instance, gather can be marked done after propagating an
+exception to the caller, therefore, calling ``gather.cancel()``
+after catching an exception (raised by one of the awaitables) from
+gather won't cancel any other awaitables.
+"""
     @overload
     def gather(  # type: ignore[overload-overlap]
         coro_or_future1: _FutureLike[_T1], coro_or_future2: _FutureLike[_T2], /, *, return_exceptions: Literal[False] = False
@@ -228,7 +342,36 @@ else:
     @overload
     def gather(  # type: ignore[overload-overlap]
         coro_or_future1: _FutureLike[_T1], /, *, loop: AbstractEventLoop | None = None, return_exceptions: Literal[False] = False
-    ) -> Future[tuple[_T1]]: ...
+    ) -> Future[tuple[_T1]]:
+        """Return a future aggregating results from the given coroutines/futures.
+
+    Coroutines will be wrapped in a future and scheduled in the event
+    loop. They will not necessarily be scheduled in the same order as
+    passed in.
+
+    All futures must share the same event loop.  If all the tasks are
+    done successfully, the returned future's result is the list of
+    results (in the order of the original sequence, not necessarily
+    the order of results arrival).  If *return_exceptions* is True,
+    exceptions in the tasks are treated the same as successful
+    results, and gathered in the result list; otherwise, the first
+    raised exception will be immediately propagated to the returned
+    future.
+
+    Cancellation: if the outer Future is cancelled, all children (that
+    have not completed yet) are also cancelled.  If any child is
+    cancelled, this is treated as if it raised CancelledError --
+    the outer Future is *not* cancelled in this case.  (This is to
+    prevent the cancellation of one child to cause other children to
+    be cancelled.)
+
+    If *return_exceptions* is False, cancelling gather() after it
+    has been marked done won't cancel any submitted awaitables.
+    For instance, gather can be marked done after propagating an
+    exception to the caller, therefore, calling ``gather.cancel()``
+    after catching an exception (raised by one of the awaitables) from
+    gather won't cancel any other awaitables.
+    """
     @overload
     def gather(  # type: ignore[overload-overlap]
         coro_or_future1: _FutureLike[_T1],
@@ -350,29 +493,134 @@ else:
     ) -> Future[list[_T | BaseException]]: ...
 
 # unlike some asyncio apis, This does strict runtime checking of actually being a coroutine, not of any future-like.
-def run_coroutine_threadsafe(coro: Coroutine[Any, Any, _T], loop: AbstractEventLoop) -> concurrent.futures.Future[_T]: ...
+def run_coroutine_threadsafe(coro: Coroutine[Any, Any, _T], loop: AbstractEventLoop) -> concurrent.futures.Future[_T]:
+    """Submit a coroutine object to a given event loop.
+
+Return a concurrent.futures.Future to access the result.
+"""
 
 if sys.version_info >= (3, 10):
-    def shield(arg: _FutureLike[_T]) -> Future[_T]: ...
+    def shield(arg: _FutureLike[_T]) -> Future[_T]:
+        """Wait for a future, shielding it from cancellation.
+
+The statement
+
+    task = asyncio.create_task(something())
+    res = await shield(task)
+
+is exactly equivalent to the statement
+
+    res = await something()
+
+*except* that if the coroutine containing it is cancelled, the
+task running in something() is not cancelled.  From the POV of
+something(), the cancellation did not happen.  But its caller is
+still cancelled, so the yield-from expression still raises
+CancelledError.  Note: If something() is cancelled by other means
+this will still cancel shield().
+
+If you want to completely ignore cancellation (not recommended)
+you can combine shield() with a try/except clause, as follows:
+
+    task = asyncio.create_task(something())
+    try:
+        res = await shield(task)
+    except CancelledError:
+        res = None
+
+Save a reference to tasks passed to this function, to avoid
+a task disappearing mid-execution. The event loop only keeps
+weak references to tasks. A task that isn't referenced elsewhere
+may get garbage collected at any time, even before it's done.
+"""
     @overload
-    async def sleep(delay: float) -> None: ...
+    async def sleep(delay: float) -> None:
+        """Coroutine that completes after a given time (in seconds).
+"""
     @overload
     async def sleep(delay: float, result: _T) -> _T: ...
-    async def wait_for(fut: _FutureLike[_T], timeout: float | None) -> _T: ...
+    async def wait_for(fut: _FutureLike[_T], timeout: float | None) -> _T:
+        """Wait for the single Future or coroutine to complete, with timeout.
+
+Coroutine will be wrapped in Task.
+
+Returns result of the Future or coroutine.  When a timeout occurs,
+it cancels the task and raises TimeoutError.  To avoid the task
+cancellation, wrap it in shield().
+
+If the wait is cancelled, the task is also cancelled.
+
+If the task suppresses the cancellation and returns a value instead,
+that value is returned.
+
+This function is a coroutine.
+"""
 
 else:
-    def shield(arg: _FutureLike[_T], *, loop: AbstractEventLoop | None = None) -> Future[_T]: ...
+    def shield(arg: _FutureLike[_T], *, loop: AbstractEventLoop | None = None) -> Future[_T]:
+        """Wait for a future, shielding it from cancellation.
+
+    The statement
+
+        res = await shield(something())
+
+    is exactly equivalent to the statement
+
+        res = await something()
+
+    *except* that if the coroutine containing it is cancelled, the
+    task running in something() is not cancelled.  From the POV of
+    something(), the cancellation did not happen.  But its caller is
+    still cancelled, so the yield-from expression still raises
+    CancelledError.  Note: If something() is cancelled by other means
+    this will still cancel shield().
+
+    If you want to completely ignore cancellation (not recommended)
+    you can combine shield() with a try/except clause, as follows:
+
+        try:
+            res = await shield(something())
+        except CancelledError:
+            res = None
+    """
     @overload
-    async def sleep(delay: float, *, loop: AbstractEventLoop | None = None) -> None: ...
+    async def sleep(delay: float, *, loop: AbstractEventLoop | None = None) -> None:
+        """Coroutine that completes after a given time (in seconds).
+"""
     @overload
     async def sleep(delay: float, result: _T, *, loop: AbstractEventLoop | None = None) -> _T: ...
-    async def wait_for(fut: _FutureLike[_T], timeout: float | None, *, loop: AbstractEventLoop | None = None) -> _T: ...
+    async def wait_for(fut: _FutureLike[_T], timeout: float | None, *, loop: AbstractEventLoop | None = None) -> _T:
+        """Wait for the single Future or coroutine to complete, with timeout.
+
+    Coroutine will be wrapped in Task.
+
+    Returns result of the Future or coroutine.  When a timeout occurs,
+    it cancels the task and raises TimeoutError.  To avoid the task
+    cancellation, wrap it in shield().
+
+    If the wait is cancelled, the task is also cancelled.
+
+    This function is a coroutine.
+    """
 
 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]]: ...
+    ) -> tuple[set[_FT], set[_FT]]:
+        """Wait for the Futures or Tasks given by fs to complete.
+
+The fs iterable must not be empty.
+
+Returns two sets of Future: (done, pending).
+
+Usage:
+
+    done, pending = await asyncio.wait(fs)
+
+Note: This does not raise TimeoutError! Futures that aren't done
+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"
@@ -382,7 +630,22 @@ elif sys.version_info >= (3, 10):
     @overload
     async def wait(  # type: ignore[overload-overlap]
         fs: Iterable[_FT], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
-    ) -> tuple[set[_FT], set[_FT]]: ...
+    ) -> tuple[set[_FT], set[_FT]]:
+        """Wait for the Futures and coroutines given by fs to complete.
+
+    The fs iterable must not be empty.
+
+    Coroutines will be wrapped in Tasks.
+
+    Returns two sets of Future: (done, pending).
+
+    Usage:
+
+        done, pending = await asyncio.wait(fs)
+
+    Note: This does not raise TimeoutError! Futures that aren't done
+    when the timeout occurs are returned in the second set.
+    """
     @overload
     async def wait(
         fs: Iterable[Awaitable[_T]], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
@@ -396,7 +659,22 @@ else:
         loop: AbstractEventLoop | None = None,
         timeout: float | None = None,
         return_when: str = "ALL_COMPLETED",
-    ) -> tuple[set[_FT], set[_FT]]: ...
+    ) -> tuple[set[_FT], set[_FT]]:
+        """Wait for the Futures and coroutines given by fs to complete.
+
+    The fs iterable must not be empty.
+
+    Coroutines will be wrapped in Tasks.
+
+    Returns two sets of Future: (done, pending).
+
+    Usage:
+
+        done, pending = await asyncio.wait(fs)
+
+    Note: This does not raise TimeoutError! Futures that aren't done
+    when the timeout occurs are returned in the second set.
+    """
     @overload
     async def wait(
         fs: Iterable[Awaitable[_T]],
@@ -411,18 +689,30 @@ if sys.version_info >= (3, 12):
 else:
     _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Coroutine[Any, Any, _T_co]
 
-def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
+def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]:
+    """Return a set of all tasks for the loop.
+"""
 
 if sys.version_info >= (3, 11):
-    def create_task(coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]: ...
+    def create_task(coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]:
+        """Schedule the execution of a coroutine object in a spawn task.
+
+Return a Task object.
+"""
 
 else:
-    def create_task(coro: _CoroutineLike[_T], *, name: str | None = None) -> Task[_T]: ...
+    def create_task(coro: _CoroutineLike[_T], *, name: str | None = None) -> Task[_T]:
+        """Schedule the execution of a coroutine object in a spawn task.
+
+    Return a Task object.
+    """
 
 if sys.version_info >= (3, 12):
     from _asyncio import current_task as current_task
 else:
-    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
+    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None:
+        """Return a currently executed task.
+"""
 
 if sys.version_info >= (3, 14):
     def eager_task_factory(
@@ -472,4 +762,21 @@ if sys.version_info >= (3, 12):
 
     def create_eager_task_factory(
         custom_task_constructor: _CustomTaskConstructor[_TaskT_co],
-    ) -> _EagerTaskFactoryType[_TaskT_co]: ...
+    ) -> _EagerTaskFactoryType[_TaskT_co]:
+        """Create a function suitable for use as a task factory on an event-loop.
+
+Example usage:
+
+    loop.set_task_factory(
+        asyncio.create_eager_task_factory(my_task_constructor))
+
+Now, tasks created will be started immediately (rather than being first
+scheduled to an event loop). The constructor argument can be any callable
+that returns a Task-compatible object and has a signature compatible
+with `Task.__init__`; it must have the `eager_start` keyword argument.
+
+Most applications will use `Task` for `custom_task_constructor` and in
+this case there's no need to call `create_eager_task_factory()`
+directly. Instead the  global `eager_task_factory` instance can be
+used. E.g. `loop.set_task_factory(asyncio.eager_task_factory)`.
+"""

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

@@ -1,3 +1,5 @@
+"""High-level support for working with threads in asyncio
+"""
 from collections.abc import Callable
 from typing import TypeVar
 from typing_extensions import ParamSpec
@@ -7,4 +9,13 @@ __all__ = ("to_thread",)
 _P = ParamSpec("_P")
 _R = TypeVar("_R")
 
-async def to_thread(func: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+async def to_thread(func: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R:
+    """Asynchronously run function *func* in a separate thread.
+
+Any *args and **kwargs supplied for this function are directly passed
+to *func*. Also, the current :class:`contextvars.Context` is propagated,
+allowing context variables from the main thread to be accessed in the
+separate thread.
+
+Return a coroutine that can be awaited to get the eventual result of *func*.
+"""

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

@@ -7,14 +7,63 @@ __all__ = ("Timeout", "timeout", "timeout_at")
 
 @final
 class Timeout:
-    def __init__(self, when: float | None) -> None: ...
+    """Asynchronous context manager for cancelling overdue coroutines.
-    def when(self) -> float | None: ...
+
-    def reschedule(self, when: float | None) -> None: ...
+Use `timeout()` or `timeout_at()` rather than instantiating this class directly.
-    def expired(self) -> bool: ...
+"""
+    def __init__(self, when: float | None) -> None:
+        """Schedule a timeout that will trigger at a given loop time.
+
+- If `when` is `None`, the timeout will never trigger.
+- If `when < loop.time()`, the timeout will trigger on the next
+  iteration of the event loop.
+"""
+    def when(self) -> float | None:
+        """Return the current deadline.
+"""
+    def reschedule(self, when: float | None) -> None:
+        """Reschedule the timeout.
+"""
+    def expired(self) -> bool:
+        """Is timeout expired during execution?
+"""
     async def __aenter__(self) -> Self: ...
     async def __aexit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
 
-def timeout(delay: float | None) -> Timeout: ...
+def timeout(delay: float | None) -> Timeout:
-def timeout_at(when: float | None) -> Timeout: ...
+    """Timeout async context manager.
+
+Useful in cases when you want to apply timeout logic around block
+of code or in cases when asyncio.wait_for is not suitable. For example:
+
+>>> async with asyncio.timeout(10):  # 10 seconds timeout
+...     await long_running_task()
+
+
+delay - value in seconds or None to disable timeout logic
+
+long_running_task() is interrupted by raising asyncio.CancelledError,
+the top-most affected timeout() context manager converts CancelledError
+into TimeoutError.
+"""
+def timeout_at(when: float | None) -> Timeout:
+    """Schedule the timeout at absolute time.
+
+Like timeout() but argument gives absolute time in the same clock system
+as loop.time().
+
+Please note: it is not POSIX time but a time with
+undefined starting base, e.g. the time of the system power on.
+
+>>> async with asyncio.timeout_at(loop.time() + 10):
+...     await long_running_task()
+
+
+when - a deadline when timeout occurs or None to disable timeout logic
+
+long_running_task() is interrupted by raising asyncio.CancelledError,
+the top-most affected timeout() context manager converts CancelledError
+into TimeoutError.
+"""

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

@@ -1,3 +1,5 @@
+"""Tools to analyze tasks running in asyncio programs.
+"""
 import sys
 from collections.abc import Iterable
 from enum import Enum
@@ -31,16 +33,33 @@ class NodeType(Enum):
     TASK = 2
 
 class CycleFoundException(Exception):
+    """Raised when there is a cycle when drawing the call tree.
+"""
     cycles: list[list[int]]
     id2name: dict[int, str]
     def __init__(self, cycles: list[list[int]], id2name: dict[int, str]) -> None: ...
 
 def get_all_awaited_by(pid: SupportsIndex) -> list[_AwaitedInfo]: ...
-def build_async_tree(result: Iterable[_AwaitedInfo], task_emoji: str = "(T)", cor_emoji: str = "") -> list[list[str]]: ...
+def build_async_tree(result: Iterable[_AwaitedInfo], task_emoji: str = "(T)", cor_emoji: str = "") -> list[list[str]]:
+    """
+Build a list of strings for pretty-print an async call tree.
+
+The call tree is produced by `get_all_async_stacks()`, prefixing tasks
+with `task_emoji` and coroutine frames with `cor_emoji`.
+"""
 def build_task_table(result: Iterable[_AwaitedInfo]) -> list[list[int | str]]: ...
 
 if sys.version_info >= (3, 14):
-    def exit_with_permission_help_text() -> None: ...
+    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: ...
+def display_awaited_by_tasks_table(pid: SupportsIndex) -> None:
-def display_awaited_by_tasks_tree(pid: SupportsIndex) -> None: ...
+    """Build and print a table of all pending tasks under `pid`.
+"""
+def display_awaited_by_tasks_tree(pid: SupportsIndex) -> None:
+    """Build and print a tree of all pending tasks under `pid`.
+"""

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

@@ -1,3 +1,5 @@
+"""Abstract Transport class.
+"""
 from asyncio.events import AbstractEventLoop
 from asyncio.protocols import BaseProtocol
 from collections.abc import Iterable, Mapping
@@ -8,50 +10,215 @@ from typing import Any
 __all__ = ("BaseTransport", "ReadTransport", "WriteTransport", "Transport", "DatagramTransport", "SubprocessTransport")
 
 class BaseTransport:
+    """Base class for transports.
+"""
     __slots__ = ("_extra",)
     def __init__(self, extra: Mapping[str, Any] | None = None) -> None: ...
-    def get_extra_info(self, name: str, default: Any = None) -> Any: ...
+    def get_extra_info(self, name: str, default: Any = None) -> Any:
-    def is_closing(self) -> bool: ...
+        """Get optional transport information.
-    def close(self) -> None: ...
+"""
-    def set_protocol(self, protocol: BaseProtocol) -> None: ...
+    def is_closing(self) -> bool:
-    def get_protocol(self) -> BaseProtocol: ...
+        """Return True if the transport is closing or closed.
+"""
+    def close(self) -> None:
+        """Close the transport.
+
+Buffered data will be flushed asynchronously.  No more data
+will be received.  After all buffered data is flushed, the
+protocol's connection_lost() method will (eventually) be
+called with None as its argument.
+"""
+    def set_protocol(self, protocol: BaseProtocol) -> None:
+        """Set a new protocol.
+"""
+    def get_protocol(self) -> BaseProtocol:
+        """Return the current protocol.
+"""
 
 class ReadTransport(BaseTransport):
+    """Interface for read-only transports.
+"""
     __slots__ = ()
-    def is_reading(self) -> bool: ...
+    def is_reading(self) -> bool:
-    def pause_reading(self) -> None: ...
+        """Return True if the transport is receiving.
-    def resume_reading(self) -> None: ...
+"""
+    def pause_reading(self) -> None:
+        """Pause the receiving end.
+
+No data will be passed to the protocol's data_received()
+method until resume_reading() is called.
+"""
+    def resume_reading(self) -> None:
+        """Resume the receiving end.
+
+Data received will once again be passed to the protocol's
+data_received() method.
+"""
 
 class WriteTransport(BaseTransport):
+    """Interface for write-only transports.
+"""
     __slots__ = ()
-    def set_write_buffer_limits(self, high: int | None = None, low: int | None = None) -> None: ...
+    def set_write_buffer_limits(self, high: int | None = None, low: int | None = None) -> None:
-    def get_write_buffer_size(self) -> int: ...
+        """Set the high- and low-water limits for write flow control.
-    def get_write_buffer_limits(self) -> tuple[int, int]: ...
+
-    def write(self, data: bytes | bytearray | memoryview[Any]) -> None: ...  # any memoryview format or shape
+These two values control when to call the protocol's
+pause_writing() and resume_writing() methods.  If specified,
+the low-water limit must be less than or equal to the
+high-water limit.  Neither value can be negative.
+
+The defaults are implementation-specific.  If only the
+high-water limit is given, the low-water limit defaults to an
+implementation-specific value less than or equal to the
+high-water limit.  Setting high to zero forces low to zero as
+well, and causes pause_writing() to be called whenever the
+buffer becomes non-empty.  Setting low to zero causes
+resume_writing() to be called only once the buffer is empty.
+Use of zero for either limit is generally sub-optimal as it
+reduces opportunities for doing I/O and computation
+concurrently.
+"""
+    def get_write_buffer_size(self) -> int:
+        """Return the current size of the write buffer.
+"""
+    def get_write_buffer_limits(self) -> tuple[int, int]:
+        """Get the high and low watermarks for write flow control.
+Return a tuple (low, high) where low and high are
+positive number of bytes.
+"""
+    def write(self, data: bytes | bytearray | memoryview[Any]) -> None:  # any memoryview format or shape
+        """Write some data bytes to the transport.
+
+This does not block; it buffers the data and arranges for it
+to be sent out asynchronously.
+"""
     def writelines(
         self, list_of_data: Iterable[bytes | bytearray | memoryview[Any]]
-    ) -> None: ...  # any memoryview format or shape
+    ) -> None:  # any memoryview format or shape
-    def write_eof(self) -> None: ...
+        """Write a list (or any iterable) of data bytes to the transport.
-    def can_write_eof(self) -> bool: ...
+
-    def abort(self) -> None: ...
+The default implementation concatenates the arguments and
+calls write() on the result.
+"""
+    def write_eof(self) -> None:
+        """Close the write end after flushing buffered data.
+
+(This is like typing ^D into a UNIX program reading from stdin.)
+
+Data may still be received.
+"""
+    def can_write_eof(self) -> bool:
+        """Return True if this transport supports write_eof(), False if not.
+"""
+    def abort(self) -> None:
+        """Close the transport immediately.
+
+Buffered data will be lost.  No more data will be received.
+The protocol's connection_lost() method will (eventually) be
+called with None as its argument.
+"""
 
 class Transport(ReadTransport, WriteTransport):
+    """Interface representing a bidirectional transport.
+
+There may be several implementations, but typically, the user does
+not implement new transports; rather, the platform provides some
+useful transports that are implemented using the platform's best
+practices.
+
+The user never instantiates a transport directly; they call a
+utility function, passing it a protocol factory and other
+information necessary to create the transport and protocol.  (E.g.
+EventLoop.create_connection() or EventLoop.create_server().)
+
+The utility function will asynchronously create a transport and a
+protocol and hook them up by calling the protocol's
+connection_made() method, passing it the transport.
+
+The implementation here raises NotImplemented for every method
+except writelines(), which calls write() in a loop.
+"""
     __slots__ = ()
 
 class DatagramTransport(BaseTransport):
+    """Interface for datagram (UDP) transports.
+"""
     __slots__ = ()
-    def sendto(self, data: bytes | bytearray | memoryview, addr: _Address | None = None) -> None: ...
+    def sendto(self, data: bytes | bytearray | memoryview, addr: _Address | None = None) -> None:
-    def abort(self) -> None: ...
+        """Send data to the transport.
+
+This does not block; it buffers the data and arranges for it
+to be sent out asynchronously.
+addr is target socket address.
+If addr is None use target address pointed on transport creation.
+If data is an empty bytes object a zero-length datagram will be
+sent.
+"""
+    def abort(self) -> None:
+        """Close the transport immediately.
+
+Buffered data will be lost.  No more data will be received.
+The protocol's connection_lost() method will (eventually) be
+called with None as its argument.
+"""
 
 class SubprocessTransport(BaseTransport):
     __slots__ = ()
-    def get_pid(self) -> int: ...
+    def get_pid(self) -> int:
-    def get_returncode(self) -> int | None: ...
+        """Get subprocess id.
-    def get_pipe_transport(self, fd: int) -> BaseTransport | None: ...
+"""
-    def send_signal(self, signal: int) -> None: ...
+    def get_returncode(self) -> int | None:
-    def terminate(self) -> None: ...
+        """Get subprocess returncode.
-    def kill(self) -> None: ...
+
+See also
+http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
+"""
+    def get_pipe_transport(self, fd: int) -> BaseTransport | None:
+        """Get transport for pipe with number fd.
+"""
+    def send_signal(self, signal: int) -> None:
+        """Send signal to subprocess.
+
+See also:
+docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
+"""
+    def terminate(self) -> None:
+        """Stop the subprocess.
+
+Alias for close() method.
+
+On Posix OSs the method sends SIGTERM to the subprocess.
+On Windows the Win32 API function TerminateProcess()
+ is called to stop the subprocess.
+
+See also:
+http://docs.python.org/3/library/subprocess#subprocess.Popen.terminate
+"""
+    def kill(self) -> None:
+        """Kill the subprocess.
+
+On Posix OSs the function sends SIGKILL to the subprocess.
+On Windows kill() is an alias for terminate().
+
+See also:
+http://docs.python.org/3/library/subprocess#subprocess.Popen.kill
+"""
 
 class _FlowControlMixin(Transport):
+    """All the logic for (write) flow control in a mix-in base class.
+
+The subclass must implement get_write_buffer_size().  It must call
+_maybe_pause_protocol() whenever the write buffer size increases,
+and _maybe_resume_protocol() whenever it decreases.  It may also
+override set_write_buffer_limits() (e.g. to specify different
+defaults).
+
+The subclass constructor must call super().__init__(extra).  This
+will call set_write_buffer_limits().
+
+The user may call set_write_buffer_limits() and
+get_write_buffer_size(), and their protocol's pause_writing() and
+resume_writing() may be called.
+"""
     __slots__ = ("_loop", "_protocol_paused", "_high_water", "_low_water")
     def __init__(self, extra: Mapping[str, Any] | None = None, loop: AbstractEventLoop | None = None) -> None: ...

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

@@ -14,6 +14,12 @@ _WriteBuffer: TypeAlias = bytearray | memoryview
 _CMSG: TypeAlias = tuple[int, int, bytes]
 
 class TransportSocket:
+    """A socket-like wrapper for exposing real transport sockets.
+
+These objects can be safely returned by APIs like
+`transport.get_extra_info('socket')`.  All potentially disruptive
+operations (like "socket.close()") are banned.
+"""
     __slots__ = ("_sock",)
     def __init__(self, sock: socket.socket) -> None: ...
     @property

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

@@ -1,3 +1,5 @@
+"""Selector event loop for Unix with signal handling.
+"""
 import sys
 import types
 from _typeshed import StrPath
@@ -50,45 +52,159 @@ if sys.version_info < (3, 14):
     if sys.version_info >= (3, 12):
         @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
         class AbstractChildWatcher:
+            """Abstract base class for monitoring child processes.
+
+Objects derived from this class monitor a collection of subprocesses and
+report their termination or interruption by a signal.
+
+New callbacks are registered with .add_child_handler(). Starting a new
+process must be done within a 'with' block to allow the watcher to suspend
+its activity until the new process if fully registered (this is needed to
+prevent a race condition in some implementations).
+
+Example:
+    with watcher:
+        proc = subprocess.Popen("sleep 1")
+        watcher.add_child_handler(proc.pid, callback)
+
+Notes:
+    Implementations of this class must be thread-safe.
+
+    Since child watcher objects may catch the SIGCHLD signal and call
+    waitpid(-1), there should be only one active object per process.
+"""
             @abstractmethod
             def add_child_handler(
                 self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
+            ) -> None:
+                """Register a new child handler.
+
+Arrange for callback(pid, returncode, *args) to be called when
+process 'pid' terminates. Specifying another callback for the same
+process replaces the previous handler.
+
+Note: callback() must be thread-safe.
+"""
             @abstractmethod
-            def remove_child_handler(self, pid: int) -> bool: ...
+            def remove_child_handler(self, pid: int) -> bool:
+                """Removes the handler for process 'pid'.
+
+The function returns True if the handler was successfully removed,
+False if there was nothing to remove.
+"""
             @abstractmethod
-            def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+            def attach_loop(self, loop: events.AbstractEventLoop | None) -> None:
+                """Attach the watcher to an event loop.
+
+If the watcher was previously attached to an event loop, then it is
+first detached before attaching to the new loop.
+
+Note: loop may be None.
+"""
             @abstractmethod
-            def close(self) -> None: ...
+            def close(self) -> None:
+                """Close the watcher.
+
+This must be called to make sure that any underlying resource is freed.
+"""
             @abstractmethod
-            def __enter__(self) -> Self: ...
+            def __enter__(self) -> Self:
+                """Enter the watcher's context and allow starting new processes
+
+This function must return self
+"""
             @abstractmethod
             def __exit__(
                 self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
-            ) -> None: ...
+            ) -> None:
+                """Exit the watcher's context
+"""
             @abstractmethod
-            def is_active(self) -> bool: ...
+            def is_active(self) -> bool:
+                """Return ``True`` if the watcher is active and is used by the event loop.
+
+Return True if the watcher is installed and ready to handle process exit
+notifications.
+
+"""
 
     else:
         class AbstractChildWatcher:
+            """Abstract base class for monitoring child processes.
+
+    Objects derived from this class monitor a collection of subprocesses and
+    report their termination or interruption by a signal.
+
+    New callbacks are registered with .add_child_handler(). Starting a new
+    process must be done within a 'with' block to allow the watcher to suspend
+    its activity until the new process if fully registered (this is needed to
+    prevent a race condition in some implementations).
+
+    Example:
+        with watcher:
+            proc = subprocess.Popen("sleep 1")
+            watcher.add_child_handler(proc.pid, callback)
+
+    Notes:
+        Implementations of this class must be thread-safe.
+
+        Since child watcher objects may catch the SIGCHLD signal and call
+        waitpid(-1), there should be only one active object per process.
+    """
             @abstractmethod
             def add_child_handler(
                 self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
+            ) -> None:
+                """Register a new child handler.
+
+        Arrange for callback(pid, returncode, *args) to be called when
+        process 'pid' terminates. Specifying another callback for the same
+        process replaces the previous handler.
+
+        Note: callback() must be thread-safe.
+        """
             @abstractmethod
-            def remove_child_handler(self, pid: int) -> bool: ...
+            def remove_child_handler(self, pid: int) -> bool:
+                """Removes the handler for process 'pid'.
+
+        The function returns True if the handler was successfully removed,
+        False if there was nothing to remove.
+"""
             @abstractmethod
-            def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+            def attach_loop(self, loop: events.AbstractEventLoop | None) -> None:
+                """Attach the watcher to an event loop.
+
+        If the watcher was previously attached to an event loop, then it is
+        first detached before attaching to the new loop.
+
+        Note: loop may be None.
+        """
             @abstractmethod
-            def close(self) -> None: ...
+            def close(self) -> None:
+                """Close the watcher.
+
+        This must be called to make sure that any underlying resource is freed.
+        """
             @abstractmethod
-            def __enter__(self) -> Self: ...
+            def __enter__(self) -> Self:
+                """Enter the watcher's context and allow starting new processes
+
+        This function must return self
+"""
             @abstractmethod
             def __exit__(
                 self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
-            ) -> None: ...
+            ) -> None:
+                """Exit the watcher's context
+"""
             @abstractmethod
-            def is_active(self) -> bool: ...
+            def is_active(self) -> bool:
+                """Return ``True`` if the watcher is active and is used by the event loop.
+
+        Return True if the watcher is installed and ready to handle process exit
+        notifications.
+
+        """
 
 if sys.platform != "win32":
     if sys.version_info < (3, 14):
@@ -102,6 +218,15 @@ if sys.platform != "win32":
 
             @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
             class SafeChildWatcher(BaseChildWatcher):
+                """'Safe' child watcher implementation.
+
+This implementation avoids disrupting other code spawning processes by
+polling explicitly each process in the SIGCHLD handler instead of calling
+os.waitpid(-1).
+
+This is a safe solution but it has a significant overhead when handling a
+big number of children (O(n) each time SIGCHLD is raised)
+"""
                 def __enter__(self) -> Self: ...
                 def __exit__(
                     self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
@@ -113,6 +238,15 @@ if sys.platform != "win32":
 
             @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
             class FastChildWatcher(BaseChildWatcher):
+                """'Fast' child watcher implementation.
+
+This implementation reaps every terminated processes by calling
+os.waitpid(-1) directly, possibly breaking other code spawning processes
+and waiting for their termination.
+
+There is no noticeable overhead when handling a big number of children
+(O(1) each time a child terminates).
+"""
                 def __enter__(self) -> Self: ...
                 def __exit__(
                     self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
@@ -131,6 +265,15 @@ if sys.platform != "win32":
                 def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
 
             class SafeChildWatcher(BaseChildWatcher):
+                """'Safe' child watcher implementation.
+
+    This implementation avoids disrupting other code spawning processes by
+    polling explicitly each process in the SIGCHLD handler instead of calling
+    os.waitpid(-1).
+
+    This is a safe solution but it has a significant overhead when handling a
+    big number of children (O(n) each time SIGCHLD is raised)
+    """
                 def __enter__(self) -> Self: ...
                 def __exit__(
                     self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
@@ -141,6 +284,15 @@ if sys.platform != "win32":
                 def remove_child_handler(self, pid: int) -> bool: ...
 
             class FastChildWatcher(BaseChildWatcher):
+                """'Fast' child watcher implementation.
+
+    This implementation reaps every terminated processes by calling
+    os.waitpid(-1) directly, possibly breaking other code spawning processes
+    and waiting for their termination.
+
+    There is no noticeable overhead when handling a big number of children
+    (O(1) each time a child terminates).
+    """
                 def __enter__(self) -> Self: ...
                 def __exit__(
                     self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
@@ -151,6 +303,10 @@ if sys.platform != "win32":
                 def remove_child_handler(self, pid: int) -> bool: ...
 
     class _UnixSelectorEventLoop(BaseSelectorEventLoop):
+        """Unix event loop.
+
+Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
+"""
         if sys.version_info >= (3, 13):
             async def create_unix_server(
                 self,
@@ -167,17 +323,33 @@ if sys.platform != "win32":
             ) -> Server: ...
 
     if sys.version_info >= (3, 14):
-        class _UnixDefaultEventLoopPolicy(events._BaseDefaultEventLoopPolicy): ...
+        class _UnixDefaultEventLoopPolicy(events._BaseDefaultEventLoopPolicy):
+            """UNIX event loop policy
+"""
     else:
         class _UnixDefaultEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+            """UNIX event loop policy with a watcher for child processes.
+"""
             if sys.version_info >= (3, 12):
                 @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
-                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                def get_child_watcher(self) -> AbstractChildWatcher:
+                    """Get the watcher for child processes.
+
+If not yet set, a ThreadedChildWatcher object is automatically created.
+"""
                 @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
-                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None:
+                    """Set the watcher for child processes.
+"""
             else:
-                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                def get_child_watcher(self) -> AbstractChildWatcher:
-                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+                    """Get the watcher for child processes.
+
+        If not yet set, a ThreadedChildWatcher object is automatically created.
+        """
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None:
+                    """Set the watcher for child processes.
+"""
 
     SelectorEventLoop = _UnixSelectorEventLoop
 
@@ -193,6 +365,16 @@ if sys.platform != "win32":
         if sys.version_info >= (3, 12):
             @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
             class MultiLoopChildWatcher(AbstractChildWatcher):
+                """A watcher that doesn't require running loop in the main thread.
+
+This implementation registers a SIGCHLD signal handler on
+instantiation (which may conflict with other code that
+install own handler for this signal).
+
+The solution is safe but it has a significant overhead when
+handling a big number of processes (*O(n)* each time a
+SIGCHLD is received).
+"""
                 def is_active(self) -> bool: ...
                 def close(self) -> None: ...
                 def __enter__(self) -> Self: ...
@@ -207,6 +389,16 @@ if sys.platform != "win32":
 
         else:
             class MultiLoopChildWatcher(AbstractChildWatcher):
+                """A watcher that doesn't require running loop in the main thread.
+
+    This implementation registers a SIGCHLD signal handler on
+    instantiation (which may conflict with other code that
+    install own handler for this signal).
+
+    The solution is safe but it has a significant overhead when
+    handling a big number of processes (*O(n)* each time a
+    SIGCHLD is received).
+    """
                 def is_active(self) -> bool: ...
                 def close(self) -> None: ...
                 def __enter__(self) -> Self: ...
@@ -221,6 +413,17 @@ if sys.platform != "win32":
 
     if sys.version_info < (3, 14):
         class ThreadedChildWatcher(AbstractChildWatcher):
+            """Threaded child watcher implementation.
+
+The watcher uses a thread per process
+for waiting for the process finish.
+
+It doesn't require subscription on POSIX signal
+but a thread creation is not free.
+
+The watcher has O(1) complexity, its performance doesn't depend
+on amount of spawn processes.
+"""
             def is_active(self) -> Literal[True]: ...
             def close(self) -> None: ...
             def __enter__(self) -> Self: ...
@@ -235,6 +438,16 @@ if sys.platform != "win32":
             def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
 
         class PidfdChildWatcher(AbstractChildWatcher):
+            """Child watcher implementation using Linux's pid file descriptors.
+
+This child watcher polls process file descriptors (pidfds) to await child
+process termination. In some respects, PidfdChildWatcher is a "Goldilocks"
+child watcher implementation. It doesn't require signals or threads, doesn't
+interfere with any processes launched outside the event loop, and scales
+linearly with the number of subprocesses launched by the event loop. The
+main disadvantage is that pidfds are specific to Linux, and only work on
+recent (5.3+) kernels.
+"""
             def __enter__(self) -> Self: ...
             def __exit__(
                 self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None

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

@@ -1,3 +1,23 @@
+"""Basic infrastructure for asynchronous socket service clients and servers.
+
+There are only two ways to have a program on a single processor do "more
+than one thing at a time".  Multi-threaded programming is the simplest and
+most popular way to do it, but there is another very different technique,
+that lets you have nearly all the advantages of multi-threading, without
+actually using multiple threads. it's really only practical if your program
+is largely I/O bound. If your program is CPU bound, then pre-emptive
+scheduled threads are probably what you really need. Network servers are
+rarely CPU-bound, however.
+
+If your operating system supports the select() system call in its I/O
+library (and nearly all do), then you can use it to juggle multiple
+communication channels at once; doing other work while your I/O is taking
+place in the "background."  Although this strategy can seem strange and
+complex, especially at first, it is in many ways easier to understand and
+control than multi-threaded programming. The module documented here solves
+many of the difficult problems for you, making the task of building
+sophisticated high-performance network servers and clients a snap.
+"""
 import sys
 from _typeshed import FileDescriptorLike, ReadableBuffer
 from socket import socket

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

@@ -1,3 +1,8 @@
+"""allow programmer to define multiple exit functions to be executed
+upon normal program termination.
+
+Two public functions, register and unregister, are defined.
+"""
 from collections.abc import Callable
 from typing import TypeVar
 from typing_extensions import ParamSpec
@@ -5,8 +10,29 @@ from typing_extensions import ParamSpec
 _T = TypeVar("_T")
 _P = ParamSpec("_P")
 
-def _clear() -> None: ...
+def _clear() -> None:
-def _ncallbacks() -> int: ...
+    """Clear the list of previously registered exit functions.
-def _run_exitfuncs() -> None: ...
+"""
-def register(func: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
+def _ncallbacks() -> int:
-def unregister(func: Callable[..., object], /) -> None: ...
+    """Return the number of registered exit functions.
+"""
+def _run_exitfuncs() -> None:
+    """Run all registered exit functions.
+
+If a callback raises an exception, it is logged with sys.unraisablehook.
+"""
+def register(func: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]:
+    """Register a function to be executed upon normal program termination
+
+    func - function to be called at exit
+    args - optional arguments to pass to func
+    kwargs - optional keyword arguments to pass to func
+
+    func is returned to facilitate usage as a decorator.
+"""
+def unregister(func: Callable[..., object], /) -> None:
+    """Unregister an exit function which was previously registered using
+atexit.register
+
+    func - function to be unregistered
+"""

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

@@ -5,26 +5,66 @@ _RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
 
 class error(Exception): ...
 
-def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes: ...
+def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes:
-def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+    """Return a fragment which is the addition of the two samples passed as parameters.
-def alaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
+"""
-def avg(fragment: Buffer, width: int, /) -> int: ...
+def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
-def avgpp(fragment: Buffer, width: int, /) -> int: ...
+    """Decode an Intel/DVI ADPCM coded fragment to a linear fragment.
-def bias(fragment: Buffer, width: int, bias: int, /) -> bytes: ...
+"""
-def byteswap(fragment: Buffer, width: int, /) -> bytes: ...
+def alaw2lin(fragment: Buffer, width: int, /) -> bytes:
-def cross(fragment: Buffer, width: int, /) -> int: ...
+    """Convert sound fragments in a-LAW encoding to linearly encoded sound fragments.
-def findfactor(fragment: Buffer, reference: Buffer, /) -> float: ...
+"""
-def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]: ...
+def avg(fragment: Buffer, width: int, /) -> int:
-def findmax(fragment: Buffer, length: int, /) -> int: ...
+    """Return the average over all samples in the fragment.
-def getsample(fragment: Buffer, width: int, index: int, /) -> int: ...
+"""
-def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+def avgpp(fragment: Buffer, width: int, /) -> int:
-def lin2alaw(fragment: Buffer, width: int, /) -> bytes: ...
+    """Return the average peak-peak value over all samples in the fragment.
-def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes: ...
+"""
-def lin2ulaw(fragment: Buffer, width: int, /) -> bytes: ...
+def bias(fragment: Buffer, width: int, bias: int, /) -> bytes:
-def max(fragment: Buffer, width: int, /) -> int: ...
+    """Return a fragment that is the original fragment with a bias added to each sample.
-def maxpp(fragment: Buffer, width: int, /) -> int: ...
+"""
-def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]: ...
+def byteswap(fragment: Buffer, width: int, /) -> bytes:
-def mul(fragment: Buffer, width: int, factor: float, /) -> bytes: ...
+    """Convert big-endian samples to little-endian and vice versa.
+"""
+def cross(fragment: Buffer, width: int, /) -> int:
+    """Return the number of zero crossings in the fragment passed as an argument.
+"""
+def findfactor(fragment: Buffer, reference: Buffer, /) -> float:
+    """Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal.
+"""
+def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]:
+    """Try to match reference as well as possible to a portion of fragment.
+"""
+def findmax(fragment: Buffer, length: int, /) -> int:
+    """Search fragment for a slice of specified number of samples with maximum energy.
+"""
+def getsample(fragment: Buffer, width: int, index: int, /) -> int:
+    """Return the value of sample index from the fragment.
+"""
+def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
+    """Convert samples to 4 bit Intel/DVI ADPCM encoding.
+"""
+def lin2alaw(fragment: Buffer, width: int, /) -> bytes:
+    """Convert samples in the audio fragment to a-LAW encoding.
+"""
+def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes:
+    """Convert samples between 1-, 2-, 3- and 4-byte formats.
+"""
+def lin2ulaw(fragment: Buffer, width: int, /) -> bytes:
+    """Convert samples in the audio fragment to u-LAW encoding.
+"""
+def max(fragment: Buffer, width: int, /) -> int:
+    """Return the maximum of the absolute value of all samples in a fragment.
+"""
+def maxpp(fragment: Buffer, width: int, /) -> int:
+    """Return the maximum peak-peak value in the sound fragment.
+"""
+def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]:
+    """Return the minimum and maximum values of all samples in the sound fragment.
+"""
+def mul(fragment: Buffer, width: int, factor: float, /) -> bytes:
+    """Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor.
+"""
 def ratecv(
     fragment: Buffer,
     width: int,
@@ -35,9 +75,21 @@ def ratecv(
     weightA: int = 1,
     weightB: int = 0,
     /,
-) -> tuple[bytes, _RatecvState]: ...
+) -> tuple[bytes, _RatecvState]:
-def reverse(fragment: Buffer, width: int, /) -> bytes: ...
+    """Convert the frame rate of the input fragment.
-def rms(fragment: Buffer, width: int, /) -> int: ...
+"""
-def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+def reverse(fragment: Buffer, width: int, /) -> bytes:
-def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+    """Reverse the samples in a fragment and returns the modified fragment.
-def ulaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
+"""
+def rms(fragment: Buffer, width: int, /) -> int:
+    """Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n).
+"""
+def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
+    """Convert a stereo fragment to a mono fragment.
+"""
+def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
+    """Generate a stereo fragment from a mono fragment.
+"""
+def ulaw2lin(fragment: Buffer, width: int, /) -> bytes:
+    """Convert sound fragments in u-LAW encoding to linearly encoded sound fragments.
+"""

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

@@ -1,3 +1,5 @@
+"""Base16, Base32, Base64 (RFC 3548), Base85 and Ascii85 data encodings
+"""
 import sys
 from _typeshed import ReadableBuffer
 from typing import IO
@@ -28,34 +30,184 @@ if sys.version_info >= (3, 10):
 if sys.version_info >= (3, 13):
     __all__ += ["z85decode", "z85encode"]
 
-def b64encode(s: ReadableBuffer, altchars: ReadableBuffer | None = None) -> bytes: ...
+def b64encode(s: ReadableBuffer, altchars: ReadableBuffer | None = None) -> bytes:
-def b64decode(s: str | ReadableBuffer, altchars: str | ReadableBuffer | None = None, validate: bool = False) -> bytes: ...
+    """Encode the bytes-like object s using Base64 and return a bytes object.
-def standard_b64encode(s: ReadableBuffer) -> bytes: ...
+
-def standard_b64decode(s: str | ReadableBuffer) -> bytes: ...
+Optional altchars should be a byte string of length 2 which specifies an
-def urlsafe_b64encode(s: ReadableBuffer) -> bytes: ...
+alternative alphabet for the '+' and '/' characters.  This allows an
-def urlsafe_b64decode(s: str | ReadableBuffer) -> bytes: ...
+application to e.g. generate url or filesystem safe Base64 strings.
-def b32encode(s: ReadableBuffer) -> bytes: ...
+"""
-def b32decode(s: str | ReadableBuffer, casefold: bool = False, map01: str | ReadableBuffer | None = None) -> bytes: ...
+def b64decode(s: str | ReadableBuffer, altchars: str | ReadableBuffer | None = None, validate: bool = False) -> bytes:
-def b16encode(s: ReadableBuffer) -> bytes: ...
+    """Decode the Base64 encoded bytes-like object or ASCII string s.
-def b16decode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
+
+Optional altchars must be a bytes-like object or ASCII string of length 2
+which specifies the alternative alphabet used instead of the '+' and '/'
+characters.
+
+The result is returned as a bytes object.  A binascii.Error is raised if
+s is incorrectly padded.
+
+If validate is False (the default), characters that are neither in the
+normal base-64 alphabet nor the alternative alphabet are discarded prior
+to the padding check.  If validate is True, these non-alphabet characters
+in the input result in a binascii.Error.
+For more information about the strict base64 check, see:
+
+https://docs.python.org/3.11/library/binascii.html#binascii.a2b_base64
+"""
+def standard_b64encode(s: ReadableBuffer) -> bytes:
+    """Encode bytes-like object s using the standard Base64 alphabet.
+
+The result is returned as a bytes object.
+"""
+def standard_b64decode(s: str | ReadableBuffer) -> bytes:
+    """Decode bytes encoded with the standard Base64 alphabet.
+
+Argument s is a bytes-like object or ASCII string to decode.  The result
+is returned as a bytes object.  A binascii.Error is raised if the input
+is incorrectly padded.  Characters that are not in the standard alphabet
+are discarded prior to the padding check.
+"""
+def urlsafe_b64encode(s: ReadableBuffer) -> bytes:
+    """Encode bytes using the URL- and filesystem-safe Base64 alphabet.
+
+Argument s is a bytes-like object to encode.  The result is returned as a
+bytes object.  The alphabet uses '-' instead of '+' and '_' instead of
+'/'.
+"""
+def urlsafe_b64decode(s: str | ReadableBuffer) -> bytes:
+    """Decode bytes using the URL- and filesystem-safe Base64 alphabet.
+
+Argument s is a bytes-like object or ASCII string to decode.  The result
+is returned as a bytes object.  A binascii.Error is raised if the input
+is incorrectly padded.  Characters that are not in the URL-safe base-64
+alphabet, and are not a plus '+' or slash '/', are discarded prior to the
+padding check.
+
+The alphabet uses '-' instead of '+' and '_' instead of '/'.
+"""
+def b32encode(s: ReadableBuffer) -> bytes:
+    """
+Encode the bytes-like objects using base32 and return a bytes object.
+"""
+def b32decode(s: str | ReadableBuffer, casefold: bool = False, map01: str | ReadableBuffer | None = None) -> bytes:
+    """
+Decode the base32 encoded bytes-like object or ASCII string s.
+
+Optional casefold is a flag specifying whether a lowercase alphabet is
+acceptable as input.  For security purposes, the default is False.
+
+RFC 3548 allows for optional mapping of the digit 0 (zero) to the
+letter O (oh), and for optional mapping of the digit 1 (one) to
+either the letter I (eye) or letter L (el).  The optional argument
+map01 when not None, specifies which letter the digit 1 should be
+mapped to (when map01 is not None, the digit 0 is always mapped to
+the letter O).  For security purposes the default is None, so that
+0 and 1 are not allowed in the input.
+
+The result is returned as a bytes object.  A binascii.Error is raised if
+the input is incorrectly padded or if there are non-alphabet
+characters present in the input.
+"""
+def b16encode(s: ReadableBuffer) -> bytes:
+    """Encode the bytes-like object s using Base16 and return a bytes object.
+    """
+def b16decode(s: str | ReadableBuffer, casefold: bool = False) -> bytes:
+    """Decode the Base16 encoded bytes-like object or ASCII string s.
+
+Optional casefold is a flag specifying whether a lowercase alphabet is
+acceptable as input.  For security purposes, the default is False.
+
+The result is returned as a bytes object.  A binascii.Error is raised if
+s is incorrectly padded or if there are non-alphabet characters present
+in the input.
+"""
 
 if sys.version_info >= (3, 10):
-    def b32hexencode(s: ReadableBuffer) -> bytes: ...
+    def b32hexencode(s: ReadableBuffer) -> bytes:
-    def b32hexdecode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
+        """
+Encode the bytes-like objects using base32hex and return a bytes object.
+"""
+    def b32hexdecode(s: str | ReadableBuffer, casefold: bool = False) -> bytes:
+        """
+Decode the base32hex encoded bytes-like object or ASCII string s.
+
+Optional casefold is a flag specifying whether a lowercase alphabet is
+acceptable as input.  For security purposes, the default is False.
+
+The result is returned as a bytes object.  A binascii.Error is raised if
+the input is incorrectly padded or if there are non-alphabet
+characters present in the input.
+"""
 
 def a85encode(
     b: ReadableBuffer, *, foldspaces: bool = False, wrapcol: int = 0, pad: bool = False, adobe: bool = False
-) -> bytes: ...
+) -> bytes:
+    """Encode bytes-like object b using Ascii85 and return a bytes object.
+
+foldspaces is an optional flag that uses the special short sequence 'y'
+instead of 4 consecutive spaces (ASCII 0x20) as supported by 'btoa'. This
+feature is not supported by the "standard" Adobe encoding.
+
+wrapcol controls whether the output should have newline (b'\\n') characters
+added to it. If this is non-zero, each output line will be at most this
+many characters long, excluding the trailing newline.
+
+pad controls whether the input is padded to a multiple of 4 before
+encoding. Note that the btoa implementation always pads.
+
+adobe controls whether the encoded byte sequence is framed with <~ and ~>,
+which is used by the Adobe implementation.
+"""
 def a85decode(
     b: str | ReadableBuffer, *, foldspaces: bool = False, adobe: bool = False, ignorechars: bytearray | bytes = b" \t\n\r\x0b"
-) -> bytes: ...
+) -> bytes:
-def b85encode(b: ReadableBuffer, pad: bool = False) -> bytes: ...
+    """Decode the Ascii85 encoded bytes-like object or ASCII string b.
-def b85decode(b: str | ReadableBuffer) -> bytes: ...
+
-def decode(input: IO[bytes], output: IO[bytes]) -> None: ...
+foldspaces is a flag that specifies whether the 'y' short sequence should be
-def encode(input: IO[bytes], output: IO[bytes]) -> None: ...
+accepted as shorthand for 4 consecutive spaces (ASCII 0x20). This feature is
-def encodebytes(s: ReadableBuffer) -> bytes: ...
+not supported by the "standard" Adobe encoding.
-def decodebytes(s: ReadableBuffer) -> bytes: ...
+
+adobe controls whether the input sequence is in Adobe Ascii85 format (i.e.
+is framed with <~ and ~>).
+
+ignorechars should be a byte string containing characters to ignore from the
+input. This should only contain whitespace characters, and by default
+contains all whitespace characters in ASCII.
+
+The result is returned as a bytes object.
+"""
+def b85encode(b: ReadableBuffer, pad: bool = False) -> bytes:
+    """Encode bytes-like object b in base85 format and return a bytes object.
+
+If pad is true, the input is padded with b'\\0' so its length is a multiple of
+4 bytes before encoding.
+"""
+def b85decode(b: str | ReadableBuffer) -> bytes:
+    """Decode the base85-encoded bytes-like object or ASCII string b
+
+The result is returned as a bytes object.
+"""
+def decode(input: IO[bytes], output: IO[bytes]) -> None:
+    """Decode a file; input and output are binary files.
+"""
+def encode(input: IO[bytes], output: IO[bytes]) -> None:
+    """Encode a file; input and output are binary files.
+"""
+def encodebytes(s: ReadableBuffer) -> bytes:
+    """Encode a bytestring into a bytes object containing multiple lines
+of base-64 data.
+"""
+def decodebytes(s: ReadableBuffer) -> bytes:
+    """Decode a bytestring of base-64 data into a bytes object.
+"""
 
 if sys.version_info >= (3, 13):
-    def z85encode(s: ReadableBuffer) -> bytes: ...
+    def z85encode(s: ReadableBuffer) -> bytes:
-    def z85decode(s: str | ReadableBuffer) -> bytes: ...
+        """Encode bytes-like object b in z85 format and return a bytes object.
+"""
+    def z85decode(s: str | ReadableBuffer) -> bytes:
+        """Decode the z85-encoded bytes-like object or ASCII string b
+
+The result is returned as a bytes object.
+"""

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

@@ -1,3 +1,5 @@
+"""Debugger basics
+"""
 import sys
 from _typeshed import ExcInfo, TraceFunction, Unused
 from collections.abc import Callable, Iterable, Iterator, Mapping
@@ -17,9 +19,23 @@ _Backend: TypeAlias = Literal["settrace", "monitoring"]
 # so we don't include the value of this constant in the stubs.
 GENERATOR_AND_COROUTINE_FLAGS: Final[int]
 
-class BdbQuit(Exception): ...
+class BdbQuit(Exception):
+    """Exception to give up completely.
+"""
 
 class Bdb:
+    """Generic Python debugger base class.
+
+This class takes care of details of the trace facility;
+a derived class should implement user interaction.
+The standard debugger class (pdb.Pdb) is an example.
+
+The optional skip argument must be an iterable of glob-style
+module name patterns.  The debugger will not step into frames
+that originate in a module that matches one of these patterns.
+Whether a frame is considered to originate in a certain module
+is determined by the __name__ in the frame globals.
+"""
     skip: set[str] | None
     breaks: dict[str, list[int]]
     fncache: dict[str, str]
@@ -35,69 +51,267 @@ class Bdb:
     else:
         def __init__(self, skip: Iterable[str] | None = None) -> None: ...
 
-    def canonic(self, filename: str) -> str: ...
+    def canonic(self, filename: str) -> str:
-    def reset(self) -> None: ...
+        """Return canonical form of filename.
+
+For real filenames, the canonical form is a case-normalized (on
+case insensitive filesystems) absolute path.  'Filenames' with
+angle brackets, such as "<stdin>", generated in interactive
+mode, are returned unchanged.
+"""
+    def reset(self) -> None:
+        """Set values of attributes as ready to start debugging.
+"""
     if sys.version_info >= (3, 12):
         @contextmanager
         def set_enterframe(self, frame: FrameType) -> Iterator[None]: ...
 
-    def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> TraceFunction: ...
+    def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> TraceFunction:
-    def dispatch_line(self, frame: FrameType) -> TraceFunction: ...
+        """Dispatch a trace function for debugged frames based on the event.
-    def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
-    def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
-    def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
-    if sys.version_info >= (3, 13):
-        def dispatch_opcode(self, frame: FrameType, arg: Unused) -> Callable[[FrameType, str, Any], TraceFunction]: ...
 
-    def is_skipped_module(self, module_name: str) -> bool: ...
+This function is installed as the trace function for debugged
-    def stop_here(self, frame: FrameType) -> bool: ...
+frames. Its return value is the new trace function, which is
-    def break_here(self, frame: FrameType) -> bool: ...
+usually itself. The default implementation decides how to
-    def do_clear(self, arg: Any) -> bool | None: ...
+dispatch a frame, depending on the type of event (passed in as a
-    def break_anywhere(self, frame: FrameType) -> bool: ...
+string) that is about to be executed.
-    def user_call(self, frame: FrameType, argument_list: None) -> None: ...
-    def user_line(self, frame: FrameType) -> None: ...
-    def user_return(self, frame: FrameType, return_value: Any) -> None: ...
-    def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
-    def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
-    if sys.version_info >= (3, 13):
-        def user_opcode(self, frame: FrameType) -> None: ...  # undocumented
 
-    def set_step(self) -> None: ...
+The event can be one of the following:
-    if sys.version_info >= (3, 13):
+    line: A new line of code is going to be executed.
-        def set_stepinstr(self) -> None: ...  # undocumented
+    call: A function is about to be called or another code block
+          is entered.
+    return: A function or other code block is about to return.
+    exception: An exception has occurred.
+    c_call: A C function is about to be called.
+    c_return: A C function has returned.
+    c_exception: A C function has raised an exception.
 
-    def set_next(self, frame: FrameType) -> None: ...
+For the Python events, specialized functions (see the dispatch_*()
-    def set_return(self, frame: FrameType) -> None: ...
+methods) are called.  For the C events, no action is taken.
-    def set_trace(self, frame: FrameType | None = None) -> None: ...
+
-    def set_continue(self) -> None: ...
+The arg parameter depends on the previous event.
-    def set_quit(self) -> None: ...
+"""
+    def dispatch_line(self, frame: FrameType) -> TraceFunction:
+        """Invoke user function and return trace function for line event.
+
+If the debugger stops on the current line, invoke
+self.user_line(). Raise BdbQuit if self.quitting is set.
+Return self.trace_dispatch to continue tracing in this scope.
+"""
+    def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction:
+        """Invoke user function and return trace function for call event.
+
+If the debugger stops on this function call, invoke
+self.user_call(). Raise BdbQuit if self.quitting is set.
+Return self.trace_dispatch to continue tracing in this scope.
+"""
+    def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction:
+        """Invoke user function and return trace function for return event.
+
+If the debugger stops on this function return, invoke
+self.user_return(). Raise BdbQuit if self.quitting is set.
+Return self.trace_dispatch to continue tracing in this scope.
+"""
+    def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction:
+        """Invoke user function and return trace function for exception event.
+
+If the debugger stops on this exception, invoke
+self.user_exception(). Raise BdbQuit if self.quitting is set.
+Return self.trace_dispatch to continue tracing in this scope.
+"""
+    if sys.version_info >= (3, 13):
+        def dispatch_opcode(self, frame: FrameType, arg: Unused) -> Callable[[FrameType, str, Any], TraceFunction]:
+            """Invoke user function and return trace function for opcode event.
+If the debugger stops on the current opcode, invoke
+self.user_opcode(). Raise BdbQuit if self.quitting is set.
+Return self.trace_dispatch to continue tracing in this scope.
+
+Opcode event will always trigger the user callback. For now the only
+opcode event is from an inline set_trace() and we want to stop there
+unconditionally.
+"""
+
+    def is_skipped_module(self, module_name: str) -> bool:
+        """Return True if module_name matches any skip pattern.
+"""
+    def stop_here(self, frame: FrameType) -> bool:
+        """Return True if frame is below the starting frame in the stack.
+"""
+    def break_here(self, frame: FrameType) -> bool:
+        """Return True if there is an effective breakpoint for this line.
+
+Check for line or function breakpoint and if in effect.
+Delete temporary breakpoints if effective() says to.
+"""
+    def do_clear(self, arg: Any) -> bool | None:
+        """Remove temporary breakpoint.
+
+Must implement in derived classes or get NotImplementedError.
+"""
+    def break_anywhere(self, frame: FrameType) -> bool:
+        """Return True if there is any breakpoint in that frame
+        """
+    def user_call(self, frame: FrameType, argument_list: None) -> None:
+        """Called if we might stop in a function.
+"""
+    def user_line(self, frame: FrameType) -> None:
+        """Called when we stop or break at a line.
+"""
+    def user_return(self, frame: FrameType, return_value: Any) -> None:
+        """Called when a return trap is set here.
+"""
+    def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None:
+        """Called when we stop on an exception.
+"""
+    def set_until(self, frame: FrameType, lineno: int | None = None) -> None:
+        """Stop when the line with the lineno greater than the current one is
+reached or when returning from current frame.
+"""
+    if sys.version_info >= (3, 13):
+        def user_opcode(self, frame: FrameType) -> None:  # undocumented
+            """Called when we are about to execute an opcode.
+"""
+
+    def set_step(self) -> None:
+        """Stop after one line of code.
+"""
+    if sys.version_info >= (3, 13):
+        def set_stepinstr(self) -> None:  # undocumented
+            """Stop before the next instruction.
+"""
+
+    def set_next(self, frame: FrameType) -> None:
+        """Stop on the next line in or below the given frame.
+"""
+    def set_return(self, frame: FrameType) -> None:
+        """Stop when returning from the given frame.
+"""
+    def set_trace(self, frame: FrameType | None = None) -> None:
+        """Start debugging from frame.
+
+If frame is not specified, debugging starts from caller's frame.
+"""
+    def set_continue(self) -> None:
+        """Stop only at breakpoints or when finished.
+
+If there are no breakpoints, set the system trace function to None.
+"""
+    def set_quit(self) -> None:
+        """Set quitting attribute to True.
+
+Raises BdbQuit exception in the next call to a dispatch_*() method.
+"""
     def set_break(
         self, filename: str, lineno: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
-    ) -> str | None: ...
+    ) -> str | None:
-    def clear_break(self, filename: str, lineno: int) -> str | None: ...
+        """Set a new breakpoint for filename:lineno.
-    def clear_bpbynumber(self, arg: SupportsInt) -> str | None: ...
+
-    def clear_all_file_breaks(self, filename: str) -> str | None: ...
+If lineno doesn't exist for the filename, return an error message.
-    def clear_all_breaks(self) -> str | None: ...
+The filename should be in canonical form.
-    def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint: ...
+"""
-    def get_break(self, filename: str, lineno: int) -> bool: ...
+    def clear_break(self, filename: str, lineno: int) -> str | None:
-    def get_breaks(self, filename: str, lineno: int) -> list[Breakpoint]: ...
+        """Delete breakpoints for filename:lineno.
-    def get_file_breaks(self, filename: str) -> list[int]: ...
+
-    def get_all_breaks(self) -> dict[str, list[int]]: ...
+If no breakpoints were set, return an error message.
-    def get_stack(self, f: FrameType | None, t: TracebackType | None) -> tuple[list[tuple[FrameType, int]], int]: ...
+"""
-    def format_stack_entry(self, frame_lineno: tuple[FrameType, int], lprefix: str = ": ") -> str: ...
+    def clear_bpbynumber(self, arg: SupportsInt) -> str | None:
+        """Delete a breakpoint by its index in Breakpoint.bpbynumber.
+
+If arg is invalid, return an error message.
+"""
+    def clear_all_file_breaks(self, filename: str) -> str | None:
+        """Delete all breakpoints in filename.
+
+If none were set, return an error message.
+"""
+    def clear_all_breaks(self) -> str | None:
+        """Delete all existing breakpoints.
+
+If none were set, return an error message.
+"""
+    def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint:
+        """Return a breakpoint by its index in Breakpoint.bybpnumber.
+
+For invalid arg values or if the breakpoint doesn't exist,
+raise a ValueError.
+"""
+    def get_break(self, filename: str, lineno: int) -> bool:
+        """Return True if there is a breakpoint for filename:lineno.
+"""
+    def get_breaks(self, filename: str, lineno: int) -> list[Breakpoint]:
+        """Return all breakpoints for filename:lineno.
+
+If no breakpoints are set, return an empty list.
+"""
+    def get_file_breaks(self, filename: str) -> list[int]:
+        """Return all lines with breakpoints for filename.
+
+If no breakpoints are set, return an empty list.
+"""
+    def get_all_breaks(self) -> dict[str, list[int]]:
+        """Return all breakpoints that are set.
+"""
+    def get_stack(self, f: FrameType | None, t: TracebackType | None) -> tuple[list[tuple[FrameType, int]], int]:
+        """Return a list of (frame, lineno) in a stack trace and a size.
+
+List starts with original calling frame, if there is one.
+Size may be number of frames above or below f.
+"""
+    def format_stack_entry(self, frame_lineno: tuple[FrameType, int], lprefix: str = ": ") -> str:
+        """Return a string with information about a stack entry.
+
+The stack entry frame_lineno is a (frame, lineno) tuple.  The
+return string contains the canonical filename, the function name
+or '<lambda>', the input arguments, the return value, and the
+line of code (if it exists).
+
+"""
     def run(
         self, cmd: str | CodeType, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None
-    ) -> None: ...
+    ) -> None:
-    def runeval(self, expr: str, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None) -> None: ...
+        """Debug a statement executed via the exec() function.
-    def runctx(self, cmd: str | CodeType, globals: dict[str, Any] | None, locals: Mapping[str, Any] | None) -> None: ...
+
-    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
+globals defaults to __main__.dict; locals defaults to globals.
+"""
+    def runeval(self, expr: str, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None) -> None:
+        """Debug an expression executed via the eval() function.
+
+globals defaults to __main__.dict; locals defaults to globals.
+"""
+    def runctx(self, cmd: str | CodeType, globals: dict[str, Any] | None, locals: Mapping[str, Any] | None) -> None:
+        """For backwards-compatibility.  Defers to run().
+"""
+    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> _T | None:
+        """Debug a single function call.
+
+Return the result of the function call.
+"""
     if sys.version_info >= (3, 14):
         def start_trace(self) -> None: ...
         def stop_trace(self) -> None: ...
-        def disable_current_event(self) -> None: ...
+        def disable_current_event(self) -> None:
-        def restart_events(self) -> None: ...
+            """Disable the current event.
+"""
+        def restart_events(self) -> None:
+            """Restart all events.
+"""
 
 class Breakpoint:
+    """Breakpoint class.
+
+Implements temporary breakpoints, ignore counts, disabling and
+(re)-enabling, and conditionals.
+
+Breakpoints are indexed by number through bpbynumber and by
+the (file, line) tuple using bplist.  The former points to a
+single instance of class Breakpoint.  The latter points to a
+list of such instances since there may be more than one
+breakpoint per line.
+
+When creating a breakpoint, its associated filename should be
+in canonical form.  If funcname is defined, a breakpoint hit will be
+counted when the first line of that function is executed.  A
+conditional breakpoint always counts a hit.
+"""
     next: int
     bplist: dict[tuple[str, int], list[Breakpoint]]
     bpbynumber: list[Breakpoint | None]
@@ -119,12 +333,54 @@ class Breakpoint:
         @staticmethod
         def clearBreakpoints() -> None: ...
 
-    def deleteMe(self) -> None: ...
+    def deleteMe(self) -> None:
-    def enable(self) -> None: ...
+        """Delete the breakpoint from the list associated to a file:line.
-    def disable(self) -> None: ...
-    def bpprint(self, out: IO[str] | None = None) -> None: ...
-    def bpformat(self) -> str: ...
 
-def checkfuncname(b: Breakpoint, frame: FrameType) -> bool: ...
+If it is the last breakpoint in that position, it also deletes
-def effective(file: str, line: int, frame: FrameType) -> tuple[Breakpoint, bool] | tuple[None, None]: ...
+the entry for the file:line.
-def set_trace() -> None: ...
+"""
+    def enable(self) -> None:
+        """Mark the breakpoint as enabled.
+"""
+    def disable(self) -> None:
+        """Mark the breakpoint as disabled.
+"""
+    def bpprint(self, out: IO[str] | None = None) -> None:
+        """Print the output of bpformat().
+
+The optional out argument directs where the output is sent
+and defaults to standard output.
+"""
+    def bpformat(self) -> str:
+        """Return a string with information about the breakpoint.
+
+The information includes the breakpoint number, temporary
+status, file:line position, break condition, number of times to
+ignore, and number of times hit.
+
+"""
+
+def checkfuncname(b: Breakpoint, frame: FrameType) -> bool:
+    """Return True if break should happen here.
+
+Whether a break should happen depends on the way that b (the breakpoint)
+was set.  If it was set via line number, check if b.line is the same as
+the one in the frame.  If it was set via function name, check if this is
+the right function and if it is on the first executable line.
+"""
+def effective(file: str, line: int, frame: FrameType) -> tuple[Breakpoint, bool] | tuple[None, None]:
+    """Return (active breakpoint, delete temporary flag) or (None, None) as
+breakpoint to act upon.
+
+The "active breakpoint" is the first entry in bplist[line, file] (which
+must exist) that is enabled, for which checkfuncname is True, and that
+has neither a False condition nor a positive ignore count.  The flag,
+meaning that a temporary breakpoint should be deleted, is False only
+when the condiion cannot be evaluated (in which case, ignore count is
+ignored).
+
+If no such entry exists, then (None, None) is returned.
+"""
+def set_trace() -> None:
+    """Start debugging with a Bdb instance from the caller's frame.
+"""

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

@@ -1,3 +1,5 @@
+"""Conversion between binary data and ASCII
+"""
 import sys
 from _typeshed import ReadableBuffer
 from typing_extensions import TypeAlias, deprecated
@@ -6,35 +8,108 @@ from typing_extensions import TypeAlias, deprecated
 # or ASCII-only strings.
 _AsciiBuffer: TypeAlias = str | ReadableBuffer
 
-def a2b_uu(data: _AsciiBuffer, /) -> bytes: ...
+def a2b_uu(data: _AsciiBuffer, /) -> bytes:
-def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes: ...
+    """Decode a line of uuencoded data.
+"""
+def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes:
+    """Uuencode line of data.
+"""
 
 if sys.version_info >= (3, 11):
-    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes: ...
+    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes:
+        """Decode a line of base64 data.
+
+  strict_mode
+    When set to True, bytes that are not part of the base64 standard are not allowed.
+    The same applies to excess data after padding (= / ==).
+"""
 
 else:
-    def a2b_base64(data: _AsciiBuffer, /) -> bytes: ...
+    def a2b_base64(data: _AsciiBuffer, /) -> bytes:
+        """Decode a line of base64 data.
+"""
 
-def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes: ...
+def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes:
-def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes: ...
+    """Base64-code line of data.
-def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes: ...
+"""
+def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes:
+    """Decode a string of qp-encoded data.
+"""
+def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes:
+    """Encode a string using quoted-printable encoding.
+
+On encoding, when istext is set, newlines are not encoded, and white
+space at end of lines is.  When istext is not set, \\r and \\n (CR/LF)
+are both encoded.  When quotetabs is set, space and tabs are encoded.
+"""
 
 if sys.version_info < (3, 11):
     @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
-    def a2b_hqx(data: _AsciiBuffer, /) -> bytes: ...
+    def a2b_hqx(data: _AsciiBuffer, /) -> bytes:
+        """Decode .hqx coding.
+"""
     @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
-    def rledecode_hqx(data: ReadableBuffer, /) -> bytes: ...
+    def rledecode_hqx(data: ReadableBuffer, /) -> bytes:
+        """Decode hexbin RLE-coded string.
+"""
     @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
-    def rlecode_hqx(data: ReadableBuffer, /) -> bytes: ...
+    def rlecode_hqx(data: ReadableBuffer, /) -> bytes:
+        """Binhex RLE-code binary data.
+"""
     @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
-    def b2a_hqx(data: ReadableBuffer, /) -> bytes: ...
+    def b2a_hqx(data: ReadableBuffer, /) -> bytes:
+        """Encode .hqx data.
+"""
 
-def crc_hqx(data: ReadableBuffer, crc: int, /) -> int: ...
+def crc_hqx(data: ReadableBuffer, crc: int, /) -> int:
-def crc32(data: ReadableBuffer, crc: int = 0, /) -> int: ...
+    """Compute CRC-CCITT incrementally.
-def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = 1) -> bytes: ...
+"""
-def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = 1) -> bytes: ...
+def crc32(data: ReadableBuffer, crc: int = 0, /) -> int:
-def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes: ...
+    """Compute CRC-32 incrementally.
-def unhexlify(hexstr: _AsciiBuffer, /) -> bytes: ...
+"""
+def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = 1) -> bytes:
+    """Hexadecimal representation of binary data.
+
+  sep
+    An optional single character or byte to separate hex bytes.
+  bytes_per_sep
+    How many bytes between separators.  Positive values count from the
+    right, negative values count from the left.
+
+The return value is a bytes object.  This function is also
+available as "hexlify()".
+
+Example:
+>>> binascii.b2a_hex(b'\\xb9\\x01\\xef')
+b'b901ef'
+>>> binascii.hexlify(b'\\xb9\\x01\\xef', ':')
+b'b9:01:ef'
+>>> binascii.b2a_hex(b'\\xb9\\x01\\xef', b'_', 2)
+b'b9_01ef'
+"""
+def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = 1) -> bytes:
+    """Hexadecimal representation of binary data.
+
+  sep
+    An optional single character or byte to separate hex bytes.
+  bytes_per_sep
+    How many bytes between separators.  Positive values count from the
+    right, negative values count from the left.
+
+The return value is a bytes object.  This function is also
+available as "b2a_hex()".
+"""
+def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes:
+    """Binary data of hexadecimal representation.
+
+hexstr must contain an even number of hex digits (upper or lower case).
+This function is also available as "unhexlify()".
+"""
+def unhexlify(hexstr: _AsciiBuffer, /) -> bytes:
+    """Binary data of hexadecimal representation.
+
+hexstr must contain an even number of hex digits (upper or lower case).
+"""
 
 class Error(ValueError): ...
 class Incomplete(Exception): ...

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

@@ -1,3 +1,9 @@
+"""Macintosh binhex compression/decompression.
+
+easy interface:
+binhex(inputfilename, outputfilename)
+hexbin(inputfilename, outputfilename)
+"""
 from _typeshed import SizedBuffer
 from typing import IO, Any, Final
 from typing_extensions import TypeAlias
@@ -33,7 +39,9 @@ class BinHex:
     def write_rsrc(self, data: SizedBuffer) -> None: ...
     def close(self) -> None: ...
 
-def binhex(inp: str, out: str) -> None: ...
+def binhex(inp: str, out: str) -> None:
+    """binhex(infilename, outfilename): create binhex-encoded copy of a file
+"""
 
 class HexBin:
     def __init__(self, ifp: _FileHandleUnion) -> None: ...
@@ -42,4 +50,6 @@ class HexBin:
     def read_rsrc(self, *n: int) -> bytes: ...
     def close(self) -> None: ...
 
-def hexbin(inp: str, out: str) -> None: ...
+def hexbin(inp: str, out: str) -> None:
+    """hexbin(infilename, outfilename) - Decode binhexed file
+"""

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

@@ -1,3 +1,5 @@
+"""Bisection algorithms.
+"""
 from _bisect import *
 
 bisect = bisect_right