basedpyright 1.25.0 → 1.26.0

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

@@ -0,0 +1,286 @@
+"""Optimized C implementation for the Python pickle module."""
+
+import sys
+from _typeshed import ReadableBuffer, SupportsWrite
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from pickle import PickleBuffer as PickleBuffer
+from typing import Any, Protocol, type_check_only
+from typing_extensions import TypeAlias
+
+class _ReadableFileobj(Protocol):
+    def read(self, n: int, /) -> bytes: ...
+    def readline(self) -> bytes: ...
+
+_BufferCallback: TypeAlias = Callable[[PickleBuffer], Any] | None
+
+_ReducedType: TypeAlias = (
+    str
+    | tuple[Callable[..., Any], tuple[Any, ...]]
+    | tuple[Callable[..., Any], tuple[Any, ...], Any]
+    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None]
+    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None, Iterator[Any] | None]
+)
+
+def dump(
+    obj: Any,
+    file: SupportsWrite[bytes],
+    protocol: int | None = None,
+    *,
+    fix_imports: bool = True,
+    buffer_callback: _BufferCallback = 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 4. It was introduced in Python 3.4, 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:
+    """
+    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 4. It was introduced in Python 3.4, 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,
+    *,
+    fix_imports: bool = True,
+    encoding: str = "ASCII",
+    errors: str = "strict",
+    buffers: Iterable[Any] | None = (),
+) -> 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,
+    /,
+    *,
+    fix_imports: bool = True,
+    encoding: str = "ASCII",
+    errors: str = "strict",
+    buffers: Iterable[Any] | None = (),
+) -> 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): ...
+class UnpicklingError(PickleError): ...
+
+@type_check_only
+class PicklerMemoProxy:
+    def clear(self, /) -> None: ...
+    def copy(self, /) -> dict[int, tuple[int, Any]]: ...
+
+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 4. It was introduced in Python 3.4, 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]
+    bin: bool  # undocumented
+    def __init__(
+        self,
+        file: SupportsWrite[bytes],
+        protocol: int | None = None,
+        fix_imports: bool = True,
+        buffer_callback: _BufferCallback = None,
+    ) -> None: ...
+    @property
+    def memo(self) -> PicklerMemoProxy: ...
+    @memo.setter
+    def memo(self, value: PicklerMemoProxy | dict[int, tuple[int, Any]]) -> None: ...
+    def dump(self, obj: Any, /) -> 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.
+        """
+        ...
+    if sys.version_info >= (3, 13):
+        def persistent_id(self, obj: Any, /) -> Any: ...
+    else:
+        persistent_id: Callable[[Any], Any]
+
+@type_check_only
+class UnpicklerMemoProxy:
+    def clear(self, /) -> None: ...
+    def copy(self, /) -> dict[int, tuple[int, Any]]: ...
+
+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,
+        *,
+        fix_imports: bool = True,
+        encoding: str = "ASCII",
+        errors: str = "strict",
+        buffers: Iterable[Any] | None = (),
+    ) -> None: ...
+    @property
+    def memo(self) -> UnpicklerMemoProxy: ...
+    @memo.setter
+    def memo(self, value: UnpicklerMemoProxy | dict[int, tuple[int, Any]]) -> None: ...
+    def load(self) -> 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.
+        """
+        ...
+    if sys.version_info >= (3, 13):
+        def persistent_load(self, pid: Any, /) -> Any: ...
+    else:
+        persistent_load: Callable[[Any], Any]

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

@@ -1,3 +1,4 @@
+import sys
 from collections.abc import Iterable
 from typing import ClassVar, Literal, NoReturn
 
@@ -5,7 +6,7 @@ class Quitter:
     name: str
     eof: str
     def __init__(self, name: str, eof: str) -> None: ...
-    def __call__(self, code: int | None = None) -> NoReturn: ...
+    def __call__(self, code: sys._ExitCode = None) -> NoReturn: ...
 
 class _Printer:
     MAXLINES: ClassVar[Literal[23]]
@@ -13,4 +14,4 @@ class _Printer:
     def __call__(self) -> None: ...
 
 class _Helper:
-    def __call__(self, request: object) -> None: ...
+    def __call__(self, request: object = ...) -> None: ...

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

@@ -84,8 +84,10 @@ if sys.platform == "win32":
     SO_EXCLUSIVEADDRUSE: int
 if sys.platform != "win32":
     SO_REUSEPORT: int
+    if sys.platform != "darwin" or sys.version_info >= (3, 13):
+        SO_BINDTODEVICE: int
+
 if sys.platform != "win32" and sys.platform != "darwin":
-    SO_BINDTODEVICE: int
     SO_DOMAIN: int
     SO_MARK: int
     SO_PASSCRED: int

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

@@ -17,7 +17,7 @@ from ssl import (
     SSLWantWriteError as SSLWantWriteError,
     SSLZeroReturnError as SSLZeroReturnError,
 )
-from typing import Any, Literal, TypedDict, final, overload
+from typing import Any, ClassVar, Literal, TypedDict, final, overload
 from typing_extensions import NotRequired, Self, TypeAlias
 
 _PasswordType: TypeAlias = Callable[[], str | bytes | bytearray] | str | bytes | bytearray
@@ -216,6 +216,7 @@ class MemoryBIO:
 
 @final
 class SSLSession:
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     @property
     def has_ticket(self) -> bool:
         """Does the session contain a ticket?"""
@@ -346,9 +347,7 @@ OP_SINGLE_ECDH_USE: int
 OP_NO_COMPRESSION: int
 OP_ENABLE_MIDDLEBOX_COMPAT: int
 OP_NO_RENEGOTIATION: int
-if sys.version_info >= (3, 11):
-    OP_IGNORE_UNEXPECTED_EOF: int
-elif sys.version_info >= (3, 8) and sys.platform == "linux":
+if sys.version_info >= (3, 11) or sys.platform == "linux":
     OP_IGNORE_UNEXPECTED_EOF: int
 if sys.version_info >= (3, 12):
     OP_LEGACY_SERVER_CONNECT: int

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

@@ -28,54 +28,37 @@ def _count() -> int:
     """
     ...
 @final
-class LockType:
-    """
-    A lock object is a synchronization primitive.  To create a lock,
-    call threading.Lock().  Methods are:
-
-    acquire() -- lock the lock, possibly blocking until it can be obtained
-    release() -- unlock of the lock
-    locked() -- test whether the lock is currently locked
-
-    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.
-    """
+class RLock:
     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.
+        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,
-        but it needn't be locked by the same thread that unlocks it.
+        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.
         """
         ...
-    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:
+    __enter__ = acquire
+    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None:
         """Release the lock."""
         ...
 
@@ -103,7 +86,72 @@ if sys.version_info >= (3, 13):
         newly created thread._ThreadHandle instance.
         """
         ...
-    lock = LockType
+    @final
+    class lock:
+        """
+        A lock object is a synchronization primitive.  To create a lock,
+        call threading.Lock().  Methods are:
+
+        acquire() -- lock the lock, possibly blocking until it can be obtained
+        release() -- unlock of the lock
+        locked() -- test whether the lock is currently locked
+
+        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:
+            """Release the lock."""
+            ...
+
+    LockType = lock
+else:
+    @final
+    class LockType:
+        def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        def release(self) -> None: ...
+        def locked(self) -> bool: ...
+        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        def release_lock(self) -> None: ...
+        def locked_lock(self) -> bool: ...
+        def __enter__(self) -> bool: ...
+        def __exit__(
+            self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+        ) -> None: ...
 
 @overload
 def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int:

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

@@ -133,26 +133,41 @@ TK_VERSION: Final[str]
 class TkttType:
     def deletetimerhandler(self): ...
 
-def create(
-    screenName: str | None = None,
-    baseName: str = "",
-    className: str = "Tk",
-    interactive: bool = False,
-    wantobjects: bool = False,
-    wantTk: bool = True,
-    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
-    """
-    ...
+if sys.version_info >= (3, 13):
+    def create(
+        screenName: str | None = None,
+        baseName: str = "",
+        className: str = "Tk",
+        interactive: bool = False,
+        wantobjects: int = 0,
+        wantTk: bool = True,
+        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(
+        screenName: str | None = None,
+        baseName: str = "",
+        className: str = "Tk",
+        interactive: bool = False,
+        wantobjects: bool = False,
+        wantTk: bool = True,
+        sync: bool = False,
+        use: str | None = None,
+        /,
+    ): ...
+
 def getbusywaitinterval():
     """Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter."""
     ...

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

@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Iterable, Iterator, MutableSet
-from typing import Any, TypeVar, overload
+from typing import Any, ClassVar, TypeVar, overload
 from typing_extensions import Self
 
 if sys.version_info >= (3, 9):
@@ -21,6 +21,7 @@ class WeakSet(MutableSet[_T]):
     def copy(self) -> Self: ...
     def remove(self, item: _T) -> None: ...
     def update(self, other: Iterable[_T]) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __contains__(self, item: object) -> bool: ...
     def __len__(self) -> int: ...
     def __iter__(self) -> Iterator[_T]: ...

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

@@ -1,8 +1,8 @@
 import sys
-from _typeshed import sentinel
+from _typeshed import SupportsWrite, sentinel
 from collections.abc import Callable, Generator, Iterable, Sequence
 from re import Pattern
-from typing import IO, Any, Final, Generic, NewType, NoReturn, Protocol, TypeVar, overload
+from typing import IO, Any, ClassVar, Final, Generic, NewType, NoReturn, Protocol, TypeVar, overload
 from typing_extensions import Self, TypeAlias, deprecated
 
 __all__ = [
@@ -182,33 +182,33 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     def add_subparsers(
         self: _ArgumentParserT,
         *,
-        title: str = ...,
-        description: str | None = ...,
-        prog: str = ...,
+        title: str = "subcommands",
+        description: str | None = None,
+        prog: str | None = None,
         action: type[Action] = ...,
         option_string: str = ...,
-        dest: str | None = ...,
-        required: bool = ...,
-        help: str | None = ...,
-        metavar: str | None = ...,
+        dest: str | None = None,
+        required: bool = False,
+        help: str | None = None,
+        metavar: str | None = None,
     ) -> _SubParsersAction[_ArgumentParserT]: ...
     @overload
     def add_subparsers(
         self,
         *,
-        title: str = ...,
-        description: str | None = ...,
-        prog: str = ...,
+        title: str = "subcommands",
+        description: str | None = None,
+        prog: str | None = None,
         parser_class: type[_ArgumentParserT],
         action: type[Action] = ...,
         option_string: str = ...,
-        dest: str | None = ...,
-        required: bool = ...,
-        help: str | None = ...,
-        metavar: str | None = ...,
+        dest: str | None = None,
+        required: bool = False,
+        help: str | None = None,
+        metavar: str | None = None,
     ) -> _SubParsersAction[_ArgumentParserT]: ...
-    def print_usage(self, file: IO[str] | None = None) -> None: ...
-    def print_help(self, file: IO[str] | None = None) -> None: ...
+    def print_usage(self, file: SupportsWrite[str] | None = None) -> None: ...
+    def print_help(self, file: SupportsWrite[str] | None = None) -> None: ...
     def format_usage(self) -> str: ...
     def format_help(self) -> str: ...
     @overload
@@ -237,7 +237,13 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     # undocumented
     def _get_optional_actions(self) -> list[Action]: ...
     def _get_positional_actions(self) -> list[Action]: ...
-    def _parse_known_args(self, arg_strings: list[str], namespace: Namespace) -> tuple[Namespace, list[str]]: ...
+    if sys.version_info >= (3, 12):
+        def _parse_known_args(
+            self, arg_strings: list[str], namespace: Namespace, intermixed: bool
+        ) -> tuple[Namespace, list[str]]: ...
+    else:
+        def _parse_known_args(self, arg_strings: list[str], namespace: Namespace) -> tuple[Namespace, list[str]]: ...
+
     def _read_args_from_files(self, arg_strings: list[str]) -> list[str]: ...
     def _match_argument(self, action: Action, arg_strings_pattern: str) -> int: ...
     def _match_arguments_partial(self, actions: Sequence[Action], arg_strings_pattern: str) -> list[int]: ...
@@ -248,7 +254,7 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     def _get_value(self, action: Action, arg_string: str) -> Any: ...
     def _check_value(self, action: Action, value: Any) -> None: ...
     def _get_formatter(self) -> HelpFormatter: ...
-    def _print_message(self, message: str, file: IO[str] | None = None) -> None: ...
+    def _print_message(self, message: str, file: SupportsWrite[str] | None = None) -> None: ...
 
 class HelpFormatter:
     # undocumented
@@ -452,6 +458,7 @@ class Namespace(_AttributeHolder):
         ...
     def __contains__(self, key: str) -> bool: ...
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class FileType:
     # undocumented