basedpyright 1.18.3 → 1.18.4

package/dist/typeshed-fallback/stdlib/email/_policybase.pyi

@@ -1,11 +1,29 @@
 from abc import ABCMeta, abstractmethod
-from collections.abc import Callable
 from email.errors import MessageDefect
 from email.header import Header
 from email.message import Message
+from typing import Generic, Protocol, TypeVar, type_check_only
 from typing_extensions import Self
 
-class _PolicyBase:
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
+
+@type_check_only
+class _MessageFactory(Protocol[_MessageT]):
+    def __call__(self, policy: Policy[_MessageT]) -> _MessageT: ...
+
+# Policy below is the only known direct subclass of _PolicyBase. We therefore
+# assume that the __init__ arguments and attributes of _PolicyBase are
+# the same as those of Policy.
+class _PolicyBase(Generic[_MessageT]):
+    max_line_length: int | None
+    linesep: str
+    cte_type: str
+    raise_on_defect: bool
+    mangle_from_: bool
+    message_factory: _MessageFactory[_MessageT] | None
+    # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+    verify_generated_headers: bool
+
     def __init__(
         self,
         *,
@@ -14,7 +32,7 @@ class _PolicyBase:
         cte_type: str = "8bit",
         raise_on_defect: bool = False,
         mangle_from_: bool = ...,  # default depends on sub-class
-        message_factory: Callable[[Policy], Message] | None = None,
+        message_factory: _MessageFactory[_MessageT] | None = None,
         # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
         verify_generated_headers: bool = True,
     ) -> None: ...
@@ -26,24 +44,15 @@ class _PolicyBase:
         cte_type: str = ...,
         raise_on_defect: bool = ...,
         mangle_from_: bool = ...,
-        message_factory: Callable[[Policy], Message] | None = ...,
+        message_factory: _MessageFactory[_MessageT] | None = ...,
         # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
         verify_generated_headers: bool = ...,
     ) -> Self: ...
     def __add__(self, other: Policy) -> Self: ...
 
-class Policy(_PolicyBase, metaclass=ABCMeta):
-    max_line_length: int | None
-    linesep: str
-    cte_type: str
-    raise_on_defect: bool
-    mangle_from_: bool
-    message_factory: Callable[[Policy], Message] | None
-    # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-    verify_generated_headers: bool
-
-    def handle_defect(self, obj: Message, defect: MessageDefect) -> None: ...
-    def register_defect(self, obj: Message, defect: MessageDefect) -> None: ...
+class Policy(_PolicyBase[_MessageT], metaclass=ABCMeta):
+    def handle_defect(self, obj: _MessageT, defect: MessageDefect) -> None: ...
+    def register_defect(self, obj: _MessageT, defect: MessageDefect) -> None: ...
     def header_max_count(self, name: str) -> int | None: ...
     @abstractmethod
     def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
@@ -56,11 +65,11 @@ class Policy(_PolicyBase, metaclass=ABCMeta):
     @abstractmethod
     def fold_binary(self, name: str, value: str) -> bytes: ...
 
-class Compat32(Policy):
+class Compat32(Policy[_MessageT]):
     def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
     def header_store_parse(self, name: str, value: str) -> tuple[str, str]: ...
     def header_fetch_parse(self, name: str, value: str) -> str | Header: ...  # type: ignore[override]
     def fold(self, name: str, value: str) -> str: ...
     def fold_binary(self, name: str, value: str) -> bytes: ...
 
-compat32: Compat32
+compat32: Compat32[Message]

package/dist/typeshed-fallback/stdlib/email/feedparser.pyi

@@ -5,19 +5,19 @@ from typing import Generic, TypeVar, overload
 
 __all__ = ["FeedParser", "BytesFeedParser"]
 
-_MessageT = TypeVar("_MessageT", bound=Message)
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
 
 class FeedParser(Generic[_MessageT]):
     @overload
-    def __init__(self: FeedParser[Message], _factory: None = None, *, policy: Policy = ...) -> None: ...
+    def __init__(self: FeedParser[Message], _factory: None = None, *, policy: Policy[Message] = ...) -> None: ...
     @overload
-    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
     def feed(self, data: str) -> None: ...
     def close(self) -> _MessageT: ...
 
 class BytesFeedParser(FeedParser[_MessageT]):
     @overload
-    def __init__(self: BytesFeedParser[Message], _factory: None = None, *, policy: Policy = ...) -> None: ...
+    def __init__(self: BytesFeedParser[Message], _factory: None = None, *, policy: Policy[Message] = ...) -> None: ...
     @overload
-    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
     def feed(self, data: bytes | bytearray) -> None: ...  # type: ignore[override]

package/dist/typeshed-fallback/stdlib/email/generator.pyi

@@ -1,34 +1,71 @@
 from _typeshed import SupportsWrite
 from email.message import Message
 from email.policy import Policy
+from typing import Any, Generic, TypeVar, overload
 from typing_extensions import Self
 
 __all__ = ["Generator", "DecodedGenerator", "BytesGenerator"]
 
-class Generator:
-    def clone(self, fp: SupportsWrite[str]) -> Self: ...
-    def write(self, s: str) -> None: ...
+# By default, generators do not have a message policy.
+_MessageT = TypeVar("_MessageT", bound=Message, default=Any)
+
+class Generator(Generic[_MessageT]):
+    maxheaderlen: int | None
+    policy: Policy[_MessageT] | None
+    @overload
+    def __init__(
+        self: Generator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
     def __init__(
         self,
         outfp: SupportsWrite[str],
         mangle_from_: bool | None = None,
         maxheaderlen: int | None = None,
         *,
-        policy: Policy | None = None,
+        policy: Policy[_MessageT],
     ) -> None: ...
-    def flatten(self, msg: Message, unixfrom: bool = False, linesep: str | None = None) -> None: ...
+    def write(self, s: str) -> None: ...
+    def flatten(self, msg: _MessageT, unixfrom: bool = False, linesep: str | None = None) -> None: ...
+    def clone(self, fp: SupportsWrite[str]) -> Self: ...
 
-class BytesGenerator(Generator):
+class BytesGenerator(Generator[_MessageT]):
+    @overload
+    def __init__(
+        self: BytesGenerator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[bytes],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
     def __init__(
         self,
         outfp: SupportsWrite[bytes],
         mangle_from_: bool | None = None,
         maxheaderlen: int | None = None,
         *,
-        policy: Policy | None = None,
+        policy: Policy[_MessageT],
     ) -> None: ...
 
-class DecodedGenerator(Generator):
+class DecodedGenerator(Generator[_MessageT]):
+    @overload
+    def __init__(
+        self: DecodedGenerator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        fmt: str | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
     def __init__(
         self,
         outfp: SupportsWrite[str],
@@ -36,5 +73,5 @@ class DecodedGenerator(Generator):
         maxheaderlen: int | None = None,
         fmt: str | None = None,
         *,
-        policy: Policy | None = None,
+        policy: Policy[_MessageT],
     ) -> None: ...

package/dist/typeshed-fallback/stdlib/email/message.pyi

@@ -30,10 +30,13 @@ class _SupportsDecodeToPayload(Protocol):
     def decode(self, encoding: str, errors: str, /) -> _PayloadType | _MultipartPayloadType: ...
 
 class Message(Generic[_HeaderT, _HeaderParamT]):
-    policy: Policy  # undocumented
+    # The policy attributes and arguments in this class and its subclasses
+    # would ideally use Policy[Self], but this is not possible.
+    policy: Policy[Any]  # undocumented
     preamble: str | None
     epilogue: str | None
     defects: list[MessageDefect]
+    def __init__(self, policy: Policy[Any] = ...) -> None: ...
     def is_multipart(self) -> bool: ...
     def set_unixfrom(self, unixfrom: str) -> None: ...
     def get_unixfrom(self) -> str | None: ...
@@ -126,8 +129,8 @@ class Message(Generic[_HeaderT, _HeaderParamT]):
     def get_charsets(self, failobj: _T) -> list[str | _T]: ...
     def walk(self) -> Generator[Self, None, None]: ...
     def get_content_disposition(self) -> str | None: ...
-    def as_string(self, unixfrom: bool = False, maxheaderlen: int = 0, policy: Policy | None = None) -> str: ...
-    def as_bytes(self, unixfrom: bool = False, policy: Policy | None = None) -> bytes: ...
+    def as_string(self, unixfrom: bool = False, maxheaderlen: int = 0, policy: Policy[Any] | None = None) -> str: ...
+    def as_bytes(self, unixfrom: bool = False, policy: Policy[Any] | None = None) -> bytes: ...
     def __bytes__(self) -> bytes: ...
     def set_param(
         self,
@@ -139,13 +142,12 @@ class Message(Generic[_HeaderT, _HeaderParamT]):
         language: str = "",
         replace: bool = False,
     ) -> None: ...
-    def __init__(self, policy: Policy = ...) -> None: ...
     # The following two methods are undocumented, but a source code comment states that they are public API
     def set_raw(self, name: str, value: _HeaderParamT) -> None: ...
     def raw_items(self) -> Iterator[tuple[str, _HeaderT]]: ...
 
 class MIMEPart(Message[_HeaderRegistryT, _HeaderRegistryParamT]):
-    def __init__(self, policy: Policy | None = None) -> None: ...
+    def __init__(self, policy: Policy[Any] | None = None) -> None: ...
     def get_body(self, preferencelist: Sequence[str] = ("related", "html", "plain")) -> MIMEPart[_HeaderRegistryT] | None: ...
     def attach(self, payload: Self) -> None: ...  # type: ignore[override]
     # The attachments are created via type(self) in the attach method. It's theoretically
@@ -163,7 +165,7 @@ class MIMEPart(Message[_HeaderRegistryT, _HeaderRegistryParamT]):
     def add_attachment(self, *args: Any, content_manager: ContentManager | None = ..., **kw: Any) -> None: ...
     def clear(self) -> None: ...
     def clear_content(self) -> None: ...
-    def as_string(self, unixfrom: bool = False, maxheaderlen: int | None = None, policy: Policy | None = None) -> str: ...
+    def as_string(self, unixfrom: bool = False, maxheaderlen: int | None = None, policy: Policy[Any] | None = None) -> str: ...
     def is_attachment(self) -> bool: ...
 
 class EmailMessage(MIMEPart): ...

package/dist/typeshed-fallback/stdlib/email/parser.pyi

@@ -12,9 +12,9 @@ _MessageT = TypeVar("_MessageT", bound=Message, default=Message)
 
 class Parser(Generic[_MessageT]):
     @overload
-    def __init__(self: Parser[Message[str, str]], _class: None = None, *, policy: Policy = ...) -> None: ...
+    def __init__(self: Parser[Message[str, str]], _class: None = None, *, policy: Policy[Message[str, str]] = ...) -> None: ...
     @overload
-    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
     def parse(self, fp: SupportsRead[str], headersonly: bool = False) -> _MessageT: ...
     def parsestr(self, text: str, headersonly: bool = False) -> _MessageT: ...
 
@@ -25,9 +25,11 @@ class HeaderParser(Parser[_MessageT]):
 class BytesParser(Generic[_MessageT]):
     parser: Parser[_MessageT]
     @overload
-    def __init__(self: BytesParser[Message[str, str]], _class: None = None, *, policy: Policy = ...) -> None: ...
+    def __init__(
+        self: BytesParser[Message[str, str]], _class: None = None, *, policy: Policy[Message[str, str]] = ...
+    ) -> None: ...
     @overload
-    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
     def parse(self, fp: _WrappedBuffer, headersonly: bool = False) -> _MessageT: ...
     def parsebytes(self, text: bytes | bytearray, headersonly: bool = False) -> _MessageT: ...
 

package/dist/typeshed-fallback/stdlib/email/policy.pyi

@@ -1,16 +1,34 @@
 from collections.abc import Callable
-from email._policybase import Compat32 as Compat32, Policy as Policy, compat32 as compat32
+from email._policybase import Compat32 as Compat32, Policy as Policy, _MessageFactory, compat32 as compat32
 from email.contentmanager import ContentManager
-from email.message import Message
-from typing import Any
+from email.message import EmailMessage, Message
+from typing import Any, TypeVar, overload
 
 __all__ = ["Compat32", "compat32", "Policy", "EmailPolicy", "default", "strict", "SMTP", "HTTP"]
 
-class EmailPolicy(Policy):
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
+
+class EmailPolicy(Policy[_MessageT]):
     utf8: bool
     refold_source: str
     header_factory: Callable[[str, Any], Any]
     content_manager: ContentManager
+    @overload
+    def __init__(
+        self: EmailPolicy[EmailMessage],
+        *,
+        max_line_length: int | None = ...,
+        linesep: str = ...,
+        cte_type: str = ...,
+        raise_on_defect: bool = ...,
+        mangle_from_: bool = ...,
+        message_factory: None = None,
+        utf8: bool = ...,
+        refold_source: str = ...,
+        header_factory: Callable[[str, str], str] = ...,
+        content_manager: ContentManager = ...,
+    ) -> None: ...
+    @overload
     def __init__(
         self,
         *,
@@ -19,7 +37,7 @@ class EmailPolicy(Policy):
         cte_type: str = ...,
         raise_on_defect: bool = ...,
         mangle_from_: bool = ...,
-        message_factory: Callable[[Policy], Message] | None = ...,
+        message_factory: _MessageFactory[_MessageT] | None = ...,
         utf8: bool = ...,
         refold_source: str = ...,
         header_factory: Callable[[str, str], str] = ...,
@@ -31,8 +49,8 @@ class EmailPolicy(Policy):
     def fold(self, name: str, value: str) -> Any: ...
     def fold_binary(self, name: str, value: str) -> bytes: ...
 
-default: EmailPolicy
-SMTP: EmailPolicy
-SMTPUTF8: EmailPolicy
-HTTP: EmailPolicy
-strict: EmailPolicy
+default: EmailPolicy[EmailMessage]
+SMTP: EmailPolicy[EmailMessage]
+SMTPUTF8: EmailPolicy[EmailMessage]
+HTTP: EmailPolicy[EmailMessage]
+strict: EmailPolicy[EmailMessage]

package/dist/typeshed-fallback/stdlib/http/client.pyi

@@ -34,6 +34,7 @@ __all__ = [
 _DataType: TypeAlias = SupportsRead[bytes] | Iterable[ReadableBuffer] | ReadableBuffer
 _T = TypeVar("_T")
 _MessageT = TypeVar("_MessageT", bound=email.message.Message)
+_HeaderValue: TypeAlias = ReadableBuffer | str | int
 
 HTTP_PORT: int
 HTTPS_PORT: int
@@ -167,7 +168,7 @@ class HTTPConnection:
         method: str,
         url: str,
         body: _DataType | str | None = None,
-        headers: Mapping[str, str] = {},
+        headers: Mapping[str, _HeaderValue] = {},
         *,
         encode_chunked: bool = False,
     ) -> None: ...
@@ -180,7 +181,7 @@ class HTTPConnection:
     def connect(self) -> None: ...
     def close(self) -> None: ...
     def putrequest(self, method: str, url: str, skip_host: bool = False, skip_accept_encoding: bool = False) -> None: ...
-    def putheader(self, header: str | bytes, *argument: str | bytes) -> None: ...
+    def putheader(self, header: str | bytes, *values: _HeaderValue) -> None: ...
     def endheaders(self, message_body: _DataType | None = None, *, encode_chunked: bool = False) -> None: ...
     def send(self, data: _DataType | str) -> None: ...
 

package/dist/typeshed-fallback/stdlib/io.pyi

@@ -2,7 +2,7 @@ import abc
 import builtins
 import codecs
 import sys
-from _typeshed import FileDescriptorOrPath, ReadableBuffer, WriteableBuffer
+from _typeshed import FileDescriptorOrPath, MaybeNone, ReadableBuffer, WriteableBuffer
 from collections.abc import Callable, Iterable, Iterator
 from os import _Opener
 from types import TracebackType
@@ -187,9 +187,11 @@ class RawIOBase(IOBase):
     def readall(self) -> bytes:
         """Read until EOF, using multiple read() call."""
         ...
-    def readinto(self, buffer: WriteableBuffer, /) -> int | None: ...
-    def write(self, b: ReadableBuffer, /) -> int | None: ...
-    def read(self, size: int = -1, /) -> bytes | None: ...
+    # 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: ...
+    def write(self, b: ReadableBuffer, /) -> int | MaybeNone: ...
+    def read(self, size: int = -1, /) -> bytes | MaybeNone: ...
 
 class BufferedIOBase(IOBase):
     def detach(self) -> RawIOBase:
@@ -270,24 +272,6 @@ class FileIO(RawIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definit
     def closefd(self) -> bool:
         """True if the file descriptor will be closed by close()."""
         ...
-    def write(self, b: ReadableBuffer, /) -> int:
-        """
-        Write buffer b to file, return number of bytes written.
-
-        Only makes one system call, so not all of the data may be written.
-        The number of bytes actually written is returned.  In non-blocking mode,
-        returns None if the write would block.
-        """
-        ...
-    def read(self, size: int = -1, /) -> bytes:
-        """
-        Read at most size bytes, returned as bytes.
-
-        Only makes one system call, so 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.
-        """
-        ...
     def __enter__(self) -> Self: ...
 
 class BytesIO(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes

package/dist/typeshed-fallback/stdlib/multiprocessing/connection.pyi

@@ -1,9 +1,9 @@
 import socket
 import sys
-import types
-from _typeshed import ReadableBuffer
+from _typeshed import Incomplete, ReadableBuffer
 from collections.abc import Iterable
-from typing import Any, SupportsIndex
+from types import TracebackType
+from typing import Any, Generic, SupportsIndex, TypeVar
 from typing_extensions import Self, TypeAlias
 
 __all__ = ["Client", "Listener", "Pipe", "wait"]
@@ -11,7 +11,11 @@ __all__ = ["Client", "Listener", "Pipe", "wait"]
 # https://docs.python.org/3/library/multiprocessing.html#address-formats
 _Address: TypeAlias = str | tuple[str, int]
 
-class _ConnectionBase:
+# Defaulting to Any to avoid forcing generics on a lot of pre-existing code
+_SendT = TypeVar("_SendT", contravariant=True, default=Any)
+_RecvT = TypeVar("_RecvT", covariant=True, default=Any)
+
+class _ConnectionBase(Generic[_SendT, _RecvT]):
     def __init__(self, handle: SupportsIndex, readable: bool = True, writable: bool = True) -> None: ...
     @property
     def closed(self) -> bool:
@@ -28,27 +32,27 @@ class _ConnectionBase:
     def fileno(self) -> int: ...
     def close(self) -> None: ...
     def send_bytes(self, buf: ReadableBuffer, offset: int = 0, size: int | None = None) -> None: ...
-    def send(self, obj: Any) -> None: ...
+    def send(self, obj: _SendT) -> None: ...
     def recv_bytes(self, maxlength: int | None = None) -> bytes: ...
     def recv_bytes_into(self, buf: Any, offset: int = 0) -> int: ...
-    def recv(self) -> Any: ...
+    def recv(self) -> _RecvT: ...
     def poll(self, timeout: float | None = 0.0) -> bool: ...
     def __enter__(self) -> Self: ...
     def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: types.TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
     def __del__(self) -> None: ...
 
-class Connection(_ConnectionBase): ...
+class Connection(_ConnectionBase[_SendT, _RecvT]): ...
 
 if sys.platform == "win32":
-    class PipeConnection(_ConnectionBase): ...
+    class PipeConnection(_ConnectionBase[_SendT, _RecvT]): ...
 
 class Listener:
     def __init__(
         self, address: _Address | None = None, family: str | None = None, backlog: int = 1, authkey: bytes | None = None
     ) -> None: ...
-    def accept(self) -> Connection: ...
+    def accept(self) -> Connection[Incomplete, Incomplete]: ...
     def close(self) -> None: ...
     @property
     def address(self) -> _Address: ...
@@ -56,26 +60,30 @@ class Listener:
     def last_accepted(self) -> _Address | None: ...
     def __enter__(self) -> Self: ...
     def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: types.TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
 
+# Any: send and recv methods unused
 if sys.version_info >= (3, 12):
-    def deliver_challenge(connection: Connection, authkey: bytes, digest_name: str = "sha256") -> None: ...
+    def deliver_challenge(connection: Connection[Any, Any], authkey: bytes, digest_name: str = "sha256") -> None: ...
 
 else:
-    def deliver_challenge(connection: Connection, authkey: bytes) -> None: ...
+    def deliver_challenge(connection: Connection[Any, Any], authkey: bytes) -> None: ...
 
-def answer_challenge(connection: Connection, authkey: bytes) -> None: ...
+def answer_challenge(connection: Connection[Any, Any], authkey: bytes) -> None: ...
 def wait(
-    object_list: Iterable[Connection | socket.socket | int], timeout: float | None = None
-) -> list[Connection | socket.socket | int]: ...
-def Client(address: _Address, family: str | None = None, authkey: bytes | None = None) -> Connection: ...
+    object_list: Iterable[Connection[_SendT, _RecvT] | socket.socket | int], timeout: float | None = None
+) -> list[Connection[_SendT, _RecvT] | socket.socket | int]: ...
+def Client(address: _Address, family: str | None = None, authkey: bytes | None = None) -> Connection[Any, Any]: ...
 
 # N.B. Keep this in sync with multiprocessing.context.BaseContext.Pipe.
 # _ConnectionBase is the common base class of Connection and PipeConnection
 # and can be used in cross-platform code.
+#
+# The two connections should have the same generic types but inverted (Connection[_T1, _T2], Connection[_T2, _T1]).
+# However, TypeVars scoped entirely within a return annotation is unspecified in the spec.
 if sys.platform != "win32":
-    def Pipe(duplex: bool = True) -> tuple[Connection, Connection]: ...
+    def Pipe(duplex: bool = True) -> tuple[Connection[Any, Any], Connection[Any, Any]]: ...
 
 else:
-    def Pipe(duplex: bool = True) -> tuple[PipeConnection, PipeConnection]: ...
+    def Pipe(duplex: bool = True) -> tuple[PipeConnection[Any, Any], PipeConnection[Any, Any]]: ...

package/dist/typeshed-fallback/stdlib/multiprocessing/context.pyi

@@ -47,10 +47,13 @@ class BaseContext:
     # N.B. Keep this in sync with multiprocessing.connection.Pipe.
     # _ConnectionBase is the common base class of Connection and PipeConnection
     # and can be used in cross-platform code.
+    #
+    # The two connections should have the same generic types but inverted (Connection[_T1, _T2], Connection[_T2, _T1]).
+    # However, TypeVars scoped entirely within a return annotation is unspecified in the spec.
     if sys.platform != "win32":
-        def Pipe(self, duplex: bool = True) -> tuple[Connection, Connection]: ...
+        def Pipe(self, duplex: bool = True) -> tuple[Connection[Any, Any], Connection[Any, Any]]: ...
     else:
-        def Pipe(self, duplex: bool = True) -> tuple[PipeConnection, PipeConnection]: ...
+        def Pipe(self, duplex: bool = True) -> tuple[PipeConnection[Any, Any], PipeConnection[Any, Any]]: ...
 
     def Barrier(
         self, parties: int, action: Callable[..., object] | None = None, timeout: float | None = None

package/dist/typeshed-fallback/stdlib/multiprocessing/managers.pyi

@@ -1,7 +1,7 @@
 import queue
 import sys
 import threading
-from _typeshed import SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
+from _typeshed import Incomplete, SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
 from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping, MutableSequence, Sequence
 from types import TracebackType
 from typing import Any, AnyStr, ClassVar, Generic, SupportsIndex, TypeVar, overload
@@ -137,7 +137,9 @@ class Server:
         self, registry: dict[str, tuple[Callable[..., Any], Any, Any, Any]], address: Any, authkey: bytes, serializer: str
     ) -> None: ...
     def serve_forever(self) -> None: ...
-    def accept_connection(self, c: Connection, name: str) -> None: ...
+    def accept_connection(
+        self, c: Connection[tuple[str, str | None], tuple[str, str, Iterable[Incomplete], Mapping[str, Incomplete]]], name: str
+    ) -> None: ...
 
 class BaseManager:
     if sys.version_info >= (3, 11):

package/dist/typeshed-fallback/stdlib/multiprocessing/reduction.pyi

@@ -35,8 +35,8 @@ if sys.platform == "win32":
         handle: int, target_process: int | None = None, inheritable: bool = False, *, source_process: int | None = None
     ) -> int: ...
     def steal_handle(source_pid: int, handle: int) -> int: ...
-    def send_handle(conn: connection.PipeConnection, handle: int, destination_pid: int) -> None: ...
-    def recv_handle(conn: connection.PipeConnection) -> int: ...
+    def send_handle(conn: connection.PipeConnection[DupHandle, Any], handle: int, destination_pid: int) -> None: ...
+    def recv_handle(conn: connection.PipeConnection[Any, DupHandle]) -> int: ...
 
     class DupHandle:
         def __init__(self, handle: int, access: int, pid: int | None = None) -> None: ...

package/dist/typeshed-fallback/stdlib/profile.pyi

@@ -1,5 +1,5 @@
 from _typeshed import StrOrBytesPath
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import Any, TypeVar
 from typing_extensions import ParamSpec, Self, TypeAlias
 
@@ -7,7 +7,7 @@ __all__ = ["run", "runctx", "Profile"]
 
 def run(statement: str, filename: str | None = None, sort: str | int = -1) -> None: ...
 def runctx(
-    statement: str, globals: dict[str, Any], locals: dict[str, Any], filename: str | None = None, sort: str | int = -1
+    statement: str, globals: dict[str, Any], locals: Mapping[str, Any], filename: str | None = None, sort: str | int = -1
 ) -> None: ...
 
 _T = TypeVar("_T")
@@ -26,6 +26,6 @@ class Profile:
     def create_stats(self) -> None: ...
     def snapshot_stats(self) -> None: ...
     def run(self, cmd: str) -> Self: ...
-    def runctx(self, cmd: str, globals: dict[str, Any], locals: dict[str, Any]) -> Self: ...
+    def runctx(self, cmd: str, globals: dict[str, Any], locals: Mapping[str, Any]) -> Self: ...
     def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kw: _P.kwargs) -> _T: ...
     def calibrate(self, m: int, verbose: int = 0) -> float: ...

package/dist/typeshed-fallback/stdlib/pyexpat/__init__.pyi

@@ -5,17 +5,13 @@ from collections.abc import Callable
 from pyexpat import errors as errors, model as model
 from typing import Any, Final, final
 from typing_extensions import TypeAlias
+from xml.parsers.expat import ExpatError as ExpatError
 
 EXPAT_VERSION: Final[str]  # undocumented
 version_info: tuple[int, int, int]  # undocumented
 native_encoding: str  # undocumented
 features: list[tuple[str, int]]  # undocumented
 
-class ExpatError(Exception):
-    code: int
-    lineno: int
-    offset: int
-
 error = ExpatError
 XML_PARAM_ENTITY_PARSING_NEVER: Final = 0
 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: Final = 1

package/dist/typeshed-fallback/stdlib/re.pyi

@@ -4,7 +4,6 @@ import sre_constants
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Callable, Iterator, Mapping
-from sre_constants import error as error
 from typing import Any, AnyStr, Generic, Literal, TypeVar, final, overload
 from typing_extensions import TypeAlias
 
@@ -54,6 +53,16 @@ if sys.version_info >= (3, 13):
 
 _T = TypeVar("_T")
 
+# The implementation defines this in re._constants (version_info >= 3, 11) or
+# sre_constants. Typeshed has it here because its __module__ attribute is set to "re".
+class error(Exception):
+    msg: str
+    pattern: str | bytes | None
+    pos: int | None
+    lineno: int
+    colno: int
+    def __init__(self, msg: str, pattern: str | bytes | None = None, pos: int | None = None) -> None: ...
+
 @final
 class Match(Generic[AnyStr]):
     @property