basedpyright 1.10.3 → 1.10.4

package/dist/typeshed-fallback/commit.txt

@@ -1 +1 @@
-8d1dcdbd29e72508cb9e1c4f26d916c23ab2f478
+7ed91bc2e77ec18d28307dc6086a778ecc9c7bb3

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

@@ -47,10 +47,15 @@ AnyStr_co = TypeVar("AnyStr_co", str, bytes, covariant=True)  # noqa: Y001
 # isn't possible or a type is already partially known. In cases like these,
 # use Incomplete instead of Any as a marker. For example, use
 # "Incomplete | None" instead of "Any | None".
-Incomplete: TypeAlias = Any
+Incomplete: TypeAlias = Any  # stable
 
 # To describe a function parameter that is unused and will work with anything.
-Unused: TypeAlias = object
+Unused: TypeAlias = object  # stable
+
+# Marker for return types that include None, but where forcing the user to
+# check for None can be detrimental. Sometimes called "the Any trick". See
+# CONTRIBUTING.md for more information.
+MaybeNone: TypeAlias = Any  # stable
 
 # Used to mark arguments that default to a sentinel value. This prevents
 # stubtest from complaining about the default value not matching.

package/dist/typeshed-fallback/stdlib/asyncio/constants.pyi

@@ -15,6 +15,6 @@ if sys.version_info >= (3, 12):
     THREAD_JOIN_TIMEOUT: Literal[300]
 
 class _SendfileMode(enum.Enum):
-    UNSUPPORTED: int
-    TRY_NATIVE: int
-    FALLBACK: int
+    UNSUPPORTED = 1
+    TRY_NATIVE = 2
+    FALLBACK = 3

package/dist/typeshed-fallback/stdlib/asyncio/locks.pyi

@@ -101,10 +101,10 @@ class BoundedSemaphore(Semaphore): ...
 
 if sys.version_info >= (3, 11):
     class _BarrierState(enum.Enum):  # undocumented
-        FILLING: str
-        DRAINING: str
-        RESETTING: str
-        BROKEN: str
+        FILLING = "filling"
+        DRAINING = "draining"
+        RESETTING = "resetting"
+        BROKEN = "broken"
 
     class Barrier(_LoopBoundMixin):
         def __init__(self, parties: int) -> None: ...

package/dist/typeshed-fallback/stdlib/asyncio/sslproto.pyi

@@ -14,17 +14,17 @@ if sys.version_info >= (3, 11):
     SSLAgainErrors: tuple[type[ssl.SSLWantReadError], type[ssl.SSLSyscallError]]
 
     class SSLProtocolState(Enum):
-        UNWRAPPED: str
-        DO_HANDSHAKE: str
-        WRAPPED: str
-        FLUSHING: str
-        SHUTDOWN: str
+        UNWRAPPED = "UNWRAPPED"
+        DO_HANDSHAKE = "DO_HANDSHAKE"
+        WRAPPED = "WRAPPED"
+        FLUSHING = "FLUSHING"
+        SHUTDOWN = "SHUTDOWN"
 
     class AppProtocolState(Enum):
-        STATE_INIT: str
-        STATE_CON_MADE: str
-        STATE_EOF: str
-        STATE_CON_LOST: str
+        STATE_INIT = "STATE_INIT"
+        STATE_CON_MADE = "STATE_CON_MADE"
+        STATE_EOF = "STATE_EOF"
+        STATE_CON_LOST = "STATE_CON_LOST"
 
     def add_flowcontrol_defaults(high: int | None, low: int | None, kb: int) -> tuple[int, int]: ...
 

package/dist/typeshed-fallback/stdlib/asyncio/streams.pyi

@@ -1,8 +1,8 @@
 import ssl
 import sys
-from _typeshed import StrPath
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
-from typing import Any, SupportsIndex
+from _typeshed import ReadableBuffer, StrPath
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence, Sized
+from typing import Any, Protocol, SupportsIndex
 from typing_extensions import Self, TypeAlias
 
 from . import events, protocols, transports
@@ -23,6 +23,8 @@ else:
 
 _ClientConnectedCallback: TypeAlias = Callable[[StreamReader, StreamWriter], Awaitable[None] | None]
 
+class _ReaduntilBuffer(ReadableBuffer, Sized, Protocol): ...
+
 if sys.version_info >= (3, 10):
     async def open_connection(
         host: str | None = None,
@@ -140,8 +142,11 @@ class StreamReader(AsyncIterator[bytes]):
     def at_eof(self) -> bool: ...
     def feed_data(self, data: Iterable[SupportsIndex]) -> None: ...
     async def readline(self) -> bytes: ...
-    # Can be any buffer that supports len(); consider changing to a Protocol if PEP 688 is accepted
-    async def readuntil(self, separator: bytes | bytearray | memoryview = b"\n") -> bytes: ...
+    if sys.version_info >= (3, 13):
+        async def readuntil(self, separator: _ReaduntilBuffer | tuple[_ReaduntilBuffer, ...] = b"\n") -> bytes: ...
+    else:
+        async def readuntil(self, separator: _ReaduntilBuffer = b"\n") -> bytes: ...
+
     async def read(self, n: int = -1) -> bytes: ...
     async def readexactly(self, n: int) -> bytes: ...
     def __aiter__(self) -> Self: ...

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

@@ -31,32 +31,33 @@ if sys.version_info >= (3, 11):
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
 _T_io = TypeVar("_T_io", bound=IO[str] | None)
+_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound=bool | None, default=bool | None)
 _F = TypeVar("_F", bound=Callable[..., Any])
 _P = ParamSpec("_P")
 
 _ExitFunc: TypeAlias = Callable[[type[BaseException] | None, BaseException | None, TracebackType | None], bool | None]
-_CM_EF = TypeVar("_CM_EF", bound=AbstractContextManager[Any] | _ExitFunc)
+_CM_EF = TypeVar("_CM_EF", bound=AbstractContextManager[Any, Any] | _ExitFunc)
 
 @runtime_checkable
-class AbstractContextManager(Protocol[_T_co]):
+class AbstractContextManager(Protocol[_T_co, _ExitT_co]):
     def __enter__(self) -> _T_co: ...
     @abstractmethod
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool | None: ...
+    ) -> _ExitT_co: ...
 
 @runtime_checkable
-class AbstractAsyncContextManager(Protocol[_T_co]):
+class AbstractAsyncContextManager(Protocol[_T_co, _ExitT_co]):
     async def __aenter__(self) -> _T_co: ...
     @abstractmethod
     async def __aexit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool | None: ...
+    ) -> _ExitT_co: ...
 
 class ContextDecorator:
     def __call__(self, func: _F) -> _F: ...
 
-class _GeneratorContextManager(AbstractContextManager[_T_co], ContextDecorator):
+class _GeneratorContextManager(AbstractContextManager[_T_co, bool | None], ContextDecorator):
     # __init__ and all instance attributes are actually inherited from _GeneratorContextManagerBase
     # _GeneratorContextManagerBase is more trouble than it's worth to include in the stub; see #6676
     def __init__(self, func: Callable[..., Iterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
@@ -81,7 +82,7 @@ if sys.version_info >= (3, 10):
     class AsyncContextDecorator:
         def __call__(self, func: _AF) -> _AF: ...
 
-    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co], AsyncContextDecorator):
+    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co, bool | None], AsyncContextDecorator):
         # __init__ and these attributes are actually defined in the base class _GeneratorContextManagerBase,
         # which is more trouble than it's worth to include in the stub (see #6676)
         def __init__(self, func: Callable[..., AsyncIterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
@@ -94,7 +95,7 @@ if sys.version_info >= (3, 10):
         ) -> bool | None: ...
 
 else:
-    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co]):
+    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co, bool | None]):
         def __init__(self, func: Callable[..., AsyncIterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
         gen: AsyncGenerator[_T_co, Any]
         func: Callable[..., AsyncGenerator[_T_co, Any]]
@@ -111,7 +112,7 @@ class _SupportsClose(Protocol):
 
 _SupportsCloseT = TypeVar("_SupportsCloseT", bound=_SupportsClose)
 
-class closing(AbstractContextManager[_SupportsCloseT]):
+class closing(AbstractContextManager[_SupportsCloseT, None]):
     def __init__(self, thing: _SupportsCloseT) -> None: ...
     def __exit__(self, *exc_info: Unused) -> None: ...
 
@@ -121,17 +122,17 @@ if sys.version_info >= (3, 10):
 
     _SupportsAcloseT = TypeVar("_SupportsAcloseT", bound=_SupportsAclose)
 
-    class aclosing(AbstractAsyncContextManager[_SupportsAcloseT]):
+    class aclosing(AbstractAsyncContextManager[_SupportsAcloseT, None]):
         def __init__(self, thing: _SupportsAcloseT) -> None: ...
         async def __aexit__(self, *exc_info: Unused) -> None: ...
 
-class suppress(AbstractContextManager[None]):
+class suppress(AbstractContextManager[None, bool]):
     def __init__(self, *exceptions: type[BaseException]) -> None: ...
     def __exit__(
         self, exctype: type[BaseException] | None, excinst: BaseException | None, exctb: TracebackType | None
     ) -> bool: ...
 
-class _RedirectStream(AbstractContextManager[_T_io]):
+class _RedirectStream(AbstractContextManager[_T_io, None]):
     def __init__(self, new_target: _T_io) -> None: ...
     def __exit__(
         self, exctype: type[BaseException] | None, excinst: BaseException | None, exctb: TracebackType | None
@@ -142,8 +143,8 @@ class redirect_stderr(_RedirectStream[_T_io]): ...
 
 # In reality this is a subclass of `AbstractContextManager`;
 # see #7961 for why we don't do that in the stub
-class ExitStack(metaclass=abc.ABCMeta):
-    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
+class ExitStack(Generic[_ExitT_co], metaclass=abc.ABCMeta):
+    def enter_context(self, cm: AbstractContextManager[_T, _ExitT_co]) -> _T: ...
     def push(self, exit: _CM_EF) -> _CM_EF: ...
     def callback(self, callback: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> Callable[_P, _T]: ...
     def pop_all(self) -> Self: ...
@@ -151,18 +152,18 @@ class ExitStack(metaclass=abc.ABCMeta):
     def __enter__(self) -> Self: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool: ...
+    ) -> _ExitT_co: ...
 
 _ExitCoroFunc: TypeAlias = Callable[
     [type[BaseException] | None, BaseException | None, TracebackType | None], Awaitable[bool | None]
 ]
-_ACM_EF = TypeVar("_ACM_EF", bound=AbstractAsyncContextManager[Any] | _ExitCoroFunc)
+_ACM_EF = TypeVar("_ACM_EF", bound=AbstractAsyncContextManager[Any, Any] | _ExitCoroFunc)
 
 # In reality this is a subclass of `AbstractAsyncContextManager`;
 # see #7961 for why we don't do that in the stub
-class AsyncExitStack(metaclass=abc.ABCMeta):
-    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
-    async def enter_async_context(self, cm: AbstractAsyncContextManager[_T]) -> _T: ...
+class AsyncExitStack(Generic[_ExitT_co], metaclass=abc.ABCMeta):
+    def enter_context(self, cm: AbstractContextManager[_T, _ExitT_co]) -> _T: ...
+    async def enter_async_context(self, cm: AbstractAsyncContextManager[_T, _ExitT_co]) -> _T: ...
     def push(self, exit: _CM_EF) -> _CM_EF: ...
     def push_async_exit(self, exit: _ACM_EF) -> _ACM_EF: ...
     def callback(self, callback: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> Callable[_P, _T]: ...
@@ -177,7 +178,7 @@ class AsyncExitStack(metaclass=abc.ABCMeta):
     ) -> bool: ...
 
 if sys.version_info >= (3, 10):
-    class nullcontext(AbstractContextManager[_T], AbstractAsyncContextManager[_T]):
+    class nullcontext(AbstractContextManager[_T, None], AbstractAsyncContextManager[_T, None]):
         enter_result: _T
         @overload
         def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
@@ -189,7 +190,7 @@ if sys.version_info >= (3, 10):
         async def __aexit__(self, *exctype: Unused) -> None: ...
 
 else:
-    class nullcontext(AbstractContextManager[_T]):
+    class nullcontext(AbstractContextManager[_T, None]):
         enter_result: _T
         @overload
         def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
@@ -201,7 +202,7 @@ else:
 if sys.version_info >= (3, 11):
     _T_fd_or_any_path = TypeVar("_T_fd_or_any_path", bound=FileDescriptorOrPath)
 
-    class chdir(AbstractContextManager[None], Generic[_T_fd_or_any_path]):
+    class chdir(AbstractContextManager[None, None], Generic[_T_fd_or_any_path]):
         path: _T_fd_or_any_path
         def __init__(self, path: _T_fd_or_any_path) -> None: ...
         def __enter__(self) -> None: ...

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

@@ -3,22 +3,25 @@ from email import _ParamsType, _ParamType
 from email.charset import Charset
 from email.contentmanager import ContentManager
 from email.errors import MessageDefect
-from email.header import Header
 from email.policy import Policy
-from typing import Any, Literal, Protocol, TypeVar, overload
+from typing import Any, Generic, Literal, Protocol, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
 __all__ = ["Message", "EmailMessage"]
 
 _T = TypeVar("_T")
+# Type returned by Policy.header_fetch_parse, often str or Header.
+_HeaderT = TypeVar("_HeaderT", default=str)
+_HeaderParamT = TypeVar("_HeaderParamT", default=str)
+# Represents headers constructed by HeaderRegistry. Those are sub-classes
+# of BaseHeader and another header type.
+_HeaderRegistryT = TypeVar("_HeaderRegistryT", default=Any)
+_HeaderRegistryParamT = TypeVar("_HeaderRegistryParamT", default=Any)
+
 _PayloadType: TypeAlias = Message | str
 _EncodedPayloadType: TypeAlias = Message | bytes
 _MultipartPayloadType: TypeAlias = list[_PayloadType]
 _CharsetType: TypeAlias = Charset | str | None
-# Type returned by Policy.header_fetch_parse, often str or Header.
-_HeaderType: TypeAlias = Any
-# Type accepted by Policy.header_store_parse.
-_HeaderTypeParam: TypeAlias = str | Header | Any
 
 class _SupportsEncodeToPayload(Protocol):
     def encode(self, encoding: str, /) -> _PayloadType | _MultipartPayloadType | _SupportsDecodeToPayload: ...
@@ -26,10 +29,7 @@ class _SupportsEncodeToPayload(Protocol):
 class _SupportsDecodeToPayload(Protocol):
     def decode(self, encoding: str, errors: str, /) -> _PayloadType | _MultipartPayloadType: ...
 
-# TODO: This class should be generic over the header policy and/or the header
-# value types allowed by the policy. This depends on PEP 696 support
-# (https://github.com/python/typeshed/issues/11422).
-class Message:
+class Message(Generic[_HeaderT, _HeaderParamT]):
     policy: Policy  # undocumented
     preamble: str | None
     epilogue: str | None
@@ -70,24 +70,23 @@ class Message:
     # Same as `get` with `failobj=None`, but with the expectation that it won't return None in most scenarios
     # This is important for protocols using __getitem__, like SupportsKeysAndGetItem
     # Morally, the return type should be `AnyOf[_HeaderType, None]`,
-    # which we could spell as `_HeaderType | Any`,
-    # *but* `_HeaderType` itself is currently an alias to `Any`...
-    def __getitem__(self, name: str) -> _HeaderType: ...
-    def __setitem__(self, name: str, val: _HeaderTypeParam) -> None: ...
+    # so using "the Any trick" instead.
+    def __getitem__(self, name: str) -> _HeaderT | Any: ...
+    def __setitem__(self, name: str, val: _HeaderParamT) -> None: ...
     def __delitem__(self, name: str) -> None: ...
     def keys(self) -> list[str]: ...
-    def values(self) -> list[_HeaderType]: ...
-    def items(self) -> list[tuple[str, _HeaderType]]: ...
+    def values(self) -> list[_HeaderT]: ...
+    def items(self) -> list[tuple[str, _HeaderT]]: ...
     @overload
-    def get(self, name: str, failobj: None = None) -> _HeaderType | None: ...
+    def get(self, name: str, failobj: None = None) -> _HeaderT | None: ...
     @overload
-    def get(self, name: str, failobj: _T) -> _HeaderType | _T: ...
+    def get(self, name: str, failobj: _T) -> _HeaderT | _T: ...
     @overload
-    def get_all(self, name: str, failobj: None = None) -> list[_HeaderType] | None: ...
+    def get_all(self, name: str, failobj: None = None) -> list[_HeaderT] | None: ...
     @overload
-    def get_all(self, name: str, failobj: _T) -> list[_HeaderType] | _T: ...
+    def get_all(self, name: str, failobj: _T) -> list[_HeaderT] | _T: ...
     def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ...
-    def replace_header(self, _name: str, _value: _HeaderTypeParam) -> None: ...
+    def replace_header(self, _name: str, _value: _HeaderParamT) -> None: ...
     def get_content_type(self) -> str: ...
     def get_content_maintype(self) -> str: ...
     def get_content_subtype(self) -> str: ...
@@ -141,14 +140,14 @@ class Message:
     ) -> 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: _HeaderTypeParam) -> None: ...
-    def raw_items(self) -> Iterator[tuple[str, _HeaderType]]: ...
+    def set_raw(self, name: str, value: _HeaderParamT) -> None: ...
+    def raw_items(self) -> Iterator[tuple[str, _HeaderT]]: ...
 
-class MIMEPart(Message):
+class MIMEPart(Message[_HeaderRegistryT, _HeaderRegistryParamT]):
     def __init__(self, policy: Policy | None = None) -> None: ...
-    def get_body(self, preferencelist: Sequence[str] = ("related", "html", "plain")) -> Message | None: ...
-    def iter_attachments(self) -> Iterator[Message]: ...
-    def iter_parts(self) -> Iterator[Message]: ...
+    def get_body(self, preferencelist: Sequence[str] = ("related", "html", "plain")) -> MIMEPart[_HeaderRegistryT] | None: ...
+    def iter_attachments(self) -> Iterator[MIMEPart[_HeaderRegistryT]]: ...
+    def iter_parts(self) -> Iterator[MIMEPart[_HeaderRegistryT]]: ...
     def get_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> Any: ...
     def set_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> None: ...
     def make_related(self, boundary: str | None = None) -> None: ...

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

@@ -3,24 +3,34 @@ from collections.abc import Callable
 from email.feedparser import BytesFeedParser as BytesFeedParser, FeedParser as FeedParser
 from email.message import Message
 from email.policy import Policy
-from typing import IO
+from io import _WrappedBuffer
+from typing import Generic, TypeVar, overload
 
 __all__ = ["Parser", "HeaderParser", "BytesParser", "BytesHeaderParser", "FeedParser", "BytesFeedParser"]
 
-class Parser:
-    def __init__(self, _class: Callable[[], Message] | None = None, *, policy: Policy = ...) -> None: ...
-    def parse(self, fp: SupportsRead[str], headersonly: bool = False) -> Message: ...
-    def parsestr(self, text: str, headersonly: bool = False) -> Message: ...
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
 
-class HeaderParser(Parser):
-    def parse(self, fp: SupportsRead[str], headersonly: bool = True) -> Message: ...
-    def parsestr(self, text: str, headersonly: bool = True) -> Message: ...
+class Parser(Generic[_MessageT]):
+    @overload
+    def __init__(self: Parser[Message[str, str]], _class: None = None, *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: SupportsRead[str], headersonly: bool = False) -> _MessageT: ...
+    def parsestr(self, text: str, headersonly: bool = False) -> _MessageT: ...
 
-class BytesParser:
-    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
-    def parse(self, fp: IO[bytes], headersonly: bool = False) -> Message: ...
-    def parsebytes(self, text: bytes | bytearray, headersonly: bool = False) -> Message: ...
+class HeaderParser(Parser[_MessageT]):
+    def parse(self, fp: SupportsRead[str], headersonly: bool = True) -> _MessageT: ...
+    def parsestr(self, text: str, headersonly: bool = True) -> _MessageT: ...
 
-class BytesHeaderParser(BytesParser):
-    def parse(self, fp: IO[bytes], headersonly: bool = True) -> Message: ...
-    def parsebytes(self, text: bytes | bytearray, headersonly: bool = True) -> Message: ...
+class BytesParser(Generic[_MessageT]):
+    parser: Parser[_MessageT]
+    @overload
+    def __init__(self: BytesParser[Message[str, str]], _class: None = None, *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: _WrappedBuffer, headersonly: bool = False) -> _MessageT: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = False) -> _MessageT: ...
+
+class BytesHeaderParser(BytesParser[_MessageT]):
+    def parse(self, fp: _WrappedBuffer, headersonly: bool = True) -> _MessageT: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = True) -> _MessageT: ...

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

@@ -15,65 +15,65 @@ class HTTPStatus(IntEnum):
     def phrase(self) -> str: ...
     @property
     def description(self) -> str: ...
-    CONTINUE: int
-    SWITCHING_PROTOCOLS: int
-    PROCESSING: int
-    OK: int
-    CREATED: int
-    ACCEPTED: int
-    NON_AUTHORITATIVE_INFORMATION: int
-    NO_CONTENT: int
-    RESET_CONTENT: int
-    PARTIAL_CONTENT: int
-    MULTI_STATUS: int
-    ALREADY_REPORTED: int
-    IM_USED: int
-    MULTIPLE_CHOICES: int
-    MOVED_PERMANENTLY: int
-    FOUND: int
-    SEE_OTHER: int
-    NOT_MODIFIED: int
-    USE_PROXY: int
-    TEMPORARY_REDIRECT: int
-    PERMANENT_REDIRECT: int
-    BAD_REQUEST: int
-    UNAUTHORIZED: int
-    PAYMENT_REQUIRED: int
-    FORBIDDEN: int
-    NOT_FOUND: int
-    METHOD_NOT_ALLOWED: int
-    NOT_ACCEPTABLE: int
-    PROXY_AUTHENTICATION_REQUIRED: int
-    REQUEST_TIMEOUT: int
-    CONFLICT: int
-    GONE: int
-    LENGTH_REQUIRED: int
-    PRECONDITION_FAILED: int
-    REQUEST_ENTITY_TOO_LARGE: int
-    REQUEST_URI_TOO_LONG: int
-    UNSUPPORTED_MEDIA_TYPE: int
-    REQUESTED_RANGE_NOT_SATISFIABLE: int
-    EXPECTATION_FAILED: int
-    UNPROCESSABLE_ENTITY: int
-    LOCKED: int
-    FAILED_DEPENDENCY: int
-    UPGRADE_REQUIRED: int
-    PRECONDITION_REQUIRED: int
-    TOO_MANY_REQUESTS: int
-    REQUEST_HEADER_FIELDS_TOO_LARGE: int
-    INTERNAL_SERVER_ERROR: int
-    NOT_IMPLEMENTED: int
-    BAD_GATEWAY: int
-    SERVICE_UNAVAILABLE: int
-    GATEWAY_TIMEOUT: int
-    HTTP_VERSION_NOT_SUPPORTED: int
-    VARIANT_ALSO_NEGOTIATES: int
-    INSUFFICIENT_STORAGE: int
-    LOOP_DETECTED: int
-    NOT_EXTENDED: int
-    NETWORK_AUTHENTICATION_REQUIRED: int
-    MISDIRECTED_REQUEST: int
-    UNAVAILABLE_FOR_LEGAL_REASONS: int
+    CONTINUE = 100
+    SWITCHING_PROTOCOLS = 101
+    PROCESSING = 102
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NON_AUTHORITATIVE_INFORMATION = 203
+    NO_CONTENT = 204
+    RESET_CONTENT = 205
+    PARTIAL_CONTENT = 206
+    MULTI_STATUS = 207
+    ALREADY_REPORTED = 208
+    IM_USED = 226
+    MULTIPLE_CHOICES = 300
+    MOVED_PERMANENTLY = 301
+    FOUND = 302
+    SEE_OTHER = 303
+    NOT_MODIFIED = 304
+    USE_PROXY = 305
+    TEMPORARY_REDIRECT = 307
+    PERMANENT_REDIRECT = 308
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    PAYMENT_REQUIRED = 402
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    CONFLICT = 409
+    GONE = 410
+    LENGTH_REQUIRED = 411
+    PRECONDITION_FAILED = 412
+    REQUEST_ENTITY_TOO_LARGE = 413
+    REQUEST_URI_TOO_LONG = 414
+    UNSUPPORTED_MEDIA_TYPE = 415
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416
+    EXPECTATION_FAILED = 417
+    UNPROCESSABLE_ENTITY = 422
+    LOCKED = 423
+    FAILED_DEPENDENCY = 424
+    UPGRADE_REQUIRED = 426
+    PRECONDITION_REQUIRED = 428
+    TOO_MANY_REQUESTS = 429
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    VARIANT_ALSO_NEGOTIATES = 506
+    INSUFFICIENT_STORAGE = 507
+    LOOP_DETECTED = 508
+    NOT_EXTENDED = 510
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+    MISDIRECTED_REQUEST = 421
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451
     if sys.version_info >= (3, 9):
         EARLY_HINTS: Literal[103]
         IM_A_TEAPOT: Literal[418]
@@ -94,12 +94,12 @@ if sys.version_info >= (3, 11):
     class HTTPMethod(StrEnum):
         @property
         def description(self) -> str: ...
-        CONNECT: str
-        DELETE: str
-        GET: str
-        HEAD: str
-        OPTIONS: str
-        PATCH: str
-        POST: str
-        PUT: str
-        TRACE: str
+        CONNECT = "CONNECT"
+        DELETE = "DELETE"
+        GET = "GET"
+        HEAD = "HEAD"
+        OPTIONS = "OPTIONS"
+        PATCH = "PATCH"
+        POST = "POST"
+        PUT = "PUT"
+        TRACE = "TRACE"

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

@@ -3,7 +3,7 @@ import io
 import ssl
 import sys
 import types
-from _typeshed import ReadableBuffer, SupportsRead, WriteableBuffer
+from _typeshed import ReadableBuffer, SupportsRead, SupportsReadline, WriteableBuffer
 from collections.abc import Callable, Iterable, Iterator, Mapping
 from socket import socket
 from typing import Any, BinaryIO, TypeVar, overload
@@ -33,6 +33,7 @@ __all__ = [
 
 _DataType: TypeAlias = SupportsRead[bytes] | Iterable[ReadableBuffer] | ReadableBuffer
 _T = TypeVar("_T")
+_MessageT = TypeVar("_MessageT", bound=email.message.Message)
 
 HTTP_PORT: int
 HTTPS_PORT: int
@@ -97,28 +98,13 @@ NETWORK_AUTHENTICATION_REQUIRED: int
 
 responses: dict[int, str]
 
-class HTTPMessage(email.message.Message):
+class HTTPMessage(email.message.Message[str, str]):
     def getallmatchingheaders(self, name: str) -> list[str]: ...  # undocumented
-    # override below all of Message's methods that use `_HeaderType` / `_HeaderTypeParam` with `str`
-    # `HTTPMessage` breaks the Liskov substitution principle by only intending for `str` headers
-    # This is easier than making `Message` generic
-    def __getitem__(self, name: str) -> str | None: ...
-    def __setitem__(self, name: str, val: str) -> None: ...  # type: ignore[override]
-    def values(self) -> list[str]: ...
-    def items(self) -> list[tuple[str, str]]: ...
-    @overload
-    def get(self, name: str, failobj: None = None) -> str | None: ...
-    @overload
-    def get(self, name: str, failobj: _T) -> str | _T: ...
-    @overload
-    def get_all(self, name: str, failobj: None = None) -> list[str] | None: ...
-    @overload
-    def get_all(self, name: str, failobj: _T) -> list[str] | _T: ...
-    def replace_header(self, _name: str, _value: str) -> None: ...  # type: ignore[override]
-    def set_raw(self, name: str, value: str) -> None: ...  # type: ignore[override]
-    def raw_items(self) -> Iterator[tuple[str, str]]: ...
 
-def parse_headers(fp: io.BufferedIOBase, _class: Callable[[], email.message.Message] = ...) -> HTTPMessage: ...
+@overload
+def parse_headers(fp: SupportsReadline[bytes], _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def parse_headers(fp: SupportsReadline[bytes]) -> HTTPMessage: ...
 
 class HTTPResponse(io.BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible method definitions in the base classes
     msg: HTTPMessage