basedpyright 1.18.3 → 1.18.4

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

@@ -1,4 +1,5 @@
 import sys
+from re import error as error
 from typing import Any
 from typing_extensions import Self
 
@@ -6,14 +7,6 @@ MAXGROUPS: int
 
 MAGIC: int
 
-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: ...
-
 class _NamedIntConstant(int):
     name: Any
     def __new__(cls, value: int, name: str) -> Self: ...

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

@@ -1,18 +1,51 @@
 import enum
 import socket
 import sys
+from _ssl import (
+    _DEFAULT_CIPHERS as _DEFAULT_CIPHERS,
+    _OPENSSL_API_VERSION as _OPENSSL_API_VERSION,
+    HAS_ALPN as HAS_ALPN,
+    HAS_ECDH as HAS_ECDH,
+    HAS_NPN as HAS_NPN,
+    HAS_SNI as HAS_SNI,
+    OPENSSL_VERSION as OPENSSL_VERSION,
+    OPENSSL_VERSION_INFO as OPENSSL_VERSION_INFO,
+    OPENSSL_VERSION_NUMBER as OPENSSL_VERSION_NUMBER,
+    HAS_SSLv2 as HAS_SSLv2,
+    HAS_SSLv3 as HAS_SSLv3,
+    HAS_TLSv1 as HAS_TLSv1,
+    HAS_TLSv1_1 as HAS_TLSv1_1,
+    HAS_TLSv1_2 as HAS_TLSv1_2,
+    HAS_TLSv1_3 as HAS_TLSv1_3,
+    MemoryBIO as MemoryBIO,
+    RAND_add as RAND_add,
+    RAND_bytes as RAND_bytes,
+    RAND_status as RAND_status,
+    SSLSession as SSLSession,
+    _PasswordType as _PasswordType,  # typeshed only, but re-export for other type stubs to use
+    _SSLContext,
+)
 from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
 from collections.abc import Callable, Iterable
-from typing import Any, Literal, NamedTuple, TypedDict, final, overload
+from typing import Any, Literal, NamedTuple, TypedDict, overload
 from typing_extensions import Never, Self, TypeAlias
 
+if sys.version_info >= (3, 13):
+    from _ssl import HAS_PSK as HAS_PSK
+
+if sys.version_info < (3, 12):
+    from _ssl import RAND_pseudo_bytes as RAND_pseudo_bytes
+
+if sys.version_info < (3, 10):
+    from _ssl import RAND_egd as RAND_egd
+
+if sys.platform == "win32":
+    from _ssl import enum_certificates as enum_certificates, enum_crls as enum_crls
+
 _PCTRTT: TypeAlias = tuple[tuple[str, str], ...]
 _PCTRTTT: TypeAlias = tuple[_PCTRTT, ...]
 _PeerCertRetDictType: TypeAlias = dict[str, str | _PCTRTTT | _PCTRTT]
 _PeerCertRetType: TypeAlias = _PeerCertRetDictType | bytes | None
-_EnumRetType: TypeAlias = list[tuple[bytes, str, set[str] | bool]]
-_PasswordType: TypeAlias = Callable[[], str | bytes | bytearray] | str | bytes | bytearray
-
 _SrvnmeCbType: TypeAlias = Callable[[SSLSocket | SSLObject, str | None, SSLSocket], int | None]
 
 socket_error = OSError
@@ -98,38 +131,6 @@ else:
 
 _create_default_https_context: Callable[..., SSLContext]
 
-def RAND_bytes(n: int, /) -> bytes:
-    """Generate n cryptographically strong pseudo-random bytes."""
-    ...
-
-if sys.version_info < (3, 12):
-    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.
-        """
-        ...
-
-def RAND_status() -> bool:
-    """
-    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 RAND_egd(path: str) -> None: ...
-def RAND_add(string: str | ReadableBuffer, entropy: float, /) -> None:
-    """
-    Mix string into the OpenSSL PRNG state.
-
-    entropy (a float) is a lower bound on the entropy contained in
-    string.  See RFC 4086.
-    """
-    ...
-
 if sys.version_info < (3, 12):
     def match_hostname(cert: _PeerCertRetDictType, hostname: str) -> None: ...
 
@@ -156,10 +157,6 @@ class DefaultVerifyPaths(NamedTuple):
 
 def get_default_verify_paths() -> DefaultVerifyPaths: ...
 
-if sys.platform == "win32":
-    def enum_certificates(store_name: str) -> _EnumRetType: ...
-    def enum_crls(store_name: str) -> _EnumRetType: ...
-
 class VerifyMode(enum.IntEnum):
     CERT_NONE = 0
     CERT_OPTIONAL = 1
@@ -252,21 +249,8 @@ if sys.version_info >= (3, 11) or sys.platform == "linux":
     OP_IGNORE_UNEXPECTED_EOF: Options
 
 HAS_NEVER_CHECK_COMMON_NAME: bool
-HAS_SSLv2: bool
-HAS_SSLv3: bool
-HAS_TLSv1: bool
-HAS_TLSv1_1: bool
-HAS_TLSv1_2: bool
-HAS_TLSv1_3: bool
-HAS_ALPN: bool
-HAS_ECDH: bool
-HAS_SNI: bool
-HAS_NPN: bool
-CHANNEL_BINDING_TYPES: list[str]
 
-OPENSSL_VERSION: str
-OPENSSL_VERSION_INFO: tuple[int, int, int, int, int]
-OPENSSL_VERSION_NUMBER: int
+CHANNEL_BINDING_TYPES: list[str]
 
 class AlertDescription(enum.IntEnum):
     ALERT_DESCRIPTION_ACCESS_DENIED = 49
@@ -408,17 +392,15 @@ class TLSVersion(enum.IntEnum):
     TLSv1_2 = 771
     TLSv1_3 = 772
 
-class SSLContext:
-    check_hostname: bool
+class SSLContext(_SSLContext):
     options: Options
     verify_flags: VerifyFlags
     verify_mode: VerifyMode
     @property
-    def protocol(self) -> _SSLMethod: ...
+    def protocol(self) -> _SSLMethod: ...  # type: ignore[override]
     hostname_checks_common_name: bool
     maximum_version: TLSVersion
     minimum_version: TLSVersion
-    sni_callback: Callable[[SSLObject, str, SSLContext], None | int] | None
     # The following two attributes have class-level defaults.
     # However, the docs explicitly state that it's OK to override these attributes on instances,
     # so making these ClassVars wouldn't be appropriate
@@ -435,20 +417,6 @@ class SSLContext:
     else:
         def __new__(cls, protocol: int = ..., *args: Any, **kwargs: Any) -> Self: ...
 
-    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.
-        """
-        ...
-    def load_cert_chain(
-        self, certfile: StrOrBytesPath, keyfile: StrOrBytesPath | None = None, password: _PasswordType | None = None
-    ) -> None: ...
     def load_default_certs(self, purpose: Purpose = ...) -> None: ...
     def load_verify_locations(
         self,
@@ -517,7 +485,6 @@ class SSLContext:
         server_hostname: str | bytes | None = None,
         session: SSLSession | None = None,
     ) -> SSLObject: ...
-    def session_stats(self) -> dict[str, int]: ...
 
 class SSLObject:
     context: SSLContext
@@ -561,61 +528,6 @@ class SSLObject:
         def get_verified_chain(self) -> list[bytes]: ...
         def get_unverified_chain(self) -> list[bytes]: ...
 
-@final
-class MemoryBIO:
-    pending: int
-    eof: bool
-    def read(self, size: int = -1, /) -> bytes:
-        """
-        Read up to size bytes from the memory BIO.
-
-        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:
-    @property
-    def has_ticket(self) -> bool:
-        """Does the session contain a ticket?"""
-        ...
-    @property
-    def id(self) -> bytes:
-        """Session id"""
-        ...
-    @property
-    def ticket_lifetime_hint(self) -> int:
-        """Ticket life time hint."""
-        ...
-    @property
-    def time(self) -> int:
-        """Session creation time (seconds since epoch)."""
-        ...
-    @property
-    def timeout(self) -> int:
-        """Session timeout (delta in seconds)."""
-        ...
-    def __eq__(self, value: object, /) -> bool:
-        """Return self==value."""
-        ...
-
 class SSLErrorNumber(enum.IntEnum):
     SSL_ERROR_EOF = 8
     SSL_ERROR_INVALID_ERROR_CODE = 10

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

@@ -103,12 +103,10 @@ PAX_NAME_FIELDS: set[str]
 
 ENCODING: str
 
-_FileCreationModes: TypeAlias = Literal["a", "w", "x"]
-
 @overload
 def open(
     name: StrOrBytesPath | None = None,
-    mode: str = "r",
+    mode: Literal["r", "r:*", "r:", "r:gz", "r:bz2", "r:xz"] = "r",
     fileobj: IO[bytes] | None = None,
     bufsize: int = 10240,
     *,
@@ -121,16 +119,124 @@ def open(
     pax_headers: Mapping[str, str] | None = ...,
     debug: int | None = ...,
     errorlevel: int | None = ...,
-    compresslevel: int | None = ...,
+) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None,
+    mode: Literal["x", "x:", "a", "a:", "w", "w:"],
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    *,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None = None,
+    *,
+    mode: Literal["x", "x:", "a", "a:", "w", "w:"],
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None,
+    mode: Literal["x:gz", "x:bz2", "w:gz", "w:bz2"],
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    *,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+    compresslevel: int = 9,
+) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None = None,
+    *,
+    mode: Literal["x:gz", "x:bz2", "w:gz", "w:bz2"],
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+    compresslevel: int = 9,
+) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None,
+    mode: Literal["x:xz", "w:xz"],
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    *,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
     preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
 ) -> TarFile: ...
 @overload
 def open(
     name: StrOrBytesPath | None = None,
-    mode: _FileCreationModes = ...,
+    *,
+    mode: Literal["x:xz", "w:xz"],
     fileobj: _Fileobj | None = None,
     bufsize: int = 10240,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+    preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
+) -> TarFile: ...
+
+# TODO: Temporary fallback for modes containing pipe characters. These don't
+# work with mypy 1.10, but this should be fixed with mypy 1.11.
+# https://github.com/python/typeshed/issues/12182
+@overload
+def open(
+    name: StrOrBytesPath | None = None,
     *,
+    mode: str,
+    fileobj: IO[bytes] | None = None,
+    bufsize: int = 10240,
     format: int | None = ...,
     tarinfo: type[TarInfo] | None = ...,
     dereference: bool | None = ...,
@@ -140,7 +246,6 @@ def open(
     pax_headers: Mapping[str, str] | None = ...,
     debug: int | None = ...,
     errorlevel: int | None = ...,
-    compresslevel: int | None = ...,
     preset: int | None = ...,
 ) -> TarFile: ...
 

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

@@ -3027,27 +3027,133 @@ class Text(Widget, XView, YView):
     config = configure
     def bbox(self, index: _TextIndex) -> tuple[int, int, int, int] | None: ...  # type: ignore[override]
     def compare(self, index1: _TextIndex, op: Literal["<", "<=", "==", ">=", ">", "!="], index2: _TextIndex) -> bool: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex) -> tuple[int] | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /) -> tuple[int] | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: Literal["update"], arg2: _WhatToCount, /) -> int | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: Literal["update"], /) -> int | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /) -> tuple[int, int]: ...
-    @overload
-    def count(
-        self,
-        index1: _TextIndex,
-        index2: _TextIndex,
-        arg1: _WhatToCount | Literal["update"],
-        arg2: _WhatToCount | Literal["update"],
-        arg3: _WhatToCount | Literal["update"],
-        /,
-        *args: _WhatToCount | Literal["update"],
-    ) -> tuple[int, ...]: ...
+    if sys.version_info >= (3, 13):
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, *, return_ints: Literal[True]) -> int: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /, *, return_ints: Literal[True]
+        ) -> int: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: Literal["update"],
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[True],
+        ) -> int: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: Literal["update"],
+            /,
+            *,
+            return_ints: Literal[True],
+        ) -> int: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /, *, return_ints: Literal[True]
+        ) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+            return_ints: Literal[True],
+        ) -> tuple[int, ...]: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, *, return_ints: Literal[False] = False) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg: _WhatToCount | Literal["update"],
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: Literal["update"],
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> int | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: Literal["update"],
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> int | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+            return_ints: Literal[False] = False,
+        ) -> tuple[int, ...]: ...
+    else:
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /
+        ) -> tuple[int] | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: Literal["update"], arg2: _WhatToCount, /) -> int | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: Literal["update"], /) -> int | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+        ) -> tuple[int, ...]: ...
+
     @overload
     def debug(self, boolean: None = None) -> bool: ...
     @overload

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

@@ -133,7 +133,7 @@ class Untokenizer:
 def untokenize(iterable: Iterable[_Token]) -> Any: ...
 def detect_encoding(readline: Callable[[], bytes | bytearray]) -> tuple[str, Sequence[bytes]]: ...
 def tokenize(readline: Callable[[], bytes | bytearray]) -> Generator[TokenInfo, None, None]: ...
-def generate_tokens(readline: Callable[[], str]) -> Generator[TokenInfo, None, None]: ...  # undocumented
+def generate_tokens(readline: Callable[[], str]) -> Generator[TokenInfo, None, None]: ...
 def open(filename: FileDescriptorOrPath) -> TextIO: ...
 def group(*choices: str) -> str: ...  # undocumented
 def any(*choices: str) -> str: ...  # undocumented

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

@@ -920,13 +920,13 @@ if sys.version_info >= (3, 9):
     def get_type_hints(
         obj: _get_type_hints_obj_allowed_types,
         globalns: dict[str, Any] | None = None,
-        localns: dict[str, Any] | None = None,
+        localns: Mapping[str, Any] | None = None,
         include_extras: bool = False,
     ) -> dict[str, Any]: ...
 
 else:
     def get_type_hints(
-        obj: _get_type_hints_obj_allowed_types, globalns: dict[str, Any] | None = None, localns: dict[str, Any] | None = None
+        obj: _get_type_hints_obj_allowed_types, globalns: dict[str, Any] | None = None, localns: Mapping[str, Any] | None = None
     ) -> dict[str, Any]: ...
 
 def get_args(tp: Any) -> tuple[Any, ...]: ...
@@ -1066,13 +1066,13 @@ class ForwardRef:
             "that references a PEP 695 type parameter. It will be disallowed in Python 3.15."
         )
         def _evaluate(
-            self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None, *, recursive_guard: frozenset[str]
+            self, globalns: dict[str, Any] | None, localns: Mapping[str, Any] | None, *, recursive_guard: frozenset[str]
         ) -> Any | None: ...
         @overload
         def _evaluate(
             self,
             globalns: dict[str, Any] | None,
-            localns: dict[str, Any] | None,
+            localns: Mapping[str, Any] | None,
             type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...],
             *,
             recursive_guard: frozenset[str],
@@ -1081,17 +1081,17 @@ class ForwardRef:
         def _evaluate(
             self,
             globalns: dict[str, Any] | None,
-            localns: dict[str, Any] | None,
+            localns: Mapping[str, Any] | None,
             type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] | None = None,
             *,
             recursive_guard: frozenset[str],
         ) -> Any | None: ...
     elif sys.version_info >= (3, 9):
         def _evaluate(
-            self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None, recursive_guard: frozenset[str]
+            self, globalns: dict[str, Any] | None, localns: Mapping[str, Any] | None, recursive_guard: frozenset[str]
         ) -> Any | None: ...
     else:
-        def _evaluate(self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None) -> Any | None: ...
+        def _evaluate(self, globalns: dict[str, Any] | None, localns: Mapping[str, Any] | None) -> Any | None: ...
 
     def __eq__(self, other: object) -> bool: ...
     def __hash__(self) -> int: ...

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

@@ -269,7 +269,7 @@ OrderedDict = _Alias()
 def get_type_hints(
     obj: Callable[..., Any],
     globalns: dict[str, Any] | None = None,
-    localns: dict[str, Any] | None = None,
+    localns: Mapping[str, Any] | None = None,
     include_extras: bool = False,
 ) -> dict[str, Any]: ...
 def get_args(tp: Any) -> tuple[Any, ...]: ...

package/dist/typeshed-fallback/stdlib/unittest/mock.pyi

@@ -365,7 +365,7 @@ class _patcher:
 
 patch: _patcher
 
-class MagicMixin:
+class MagicMixin(Base):
     def __init__(self, *args: Any, **kw: Any) -> None: ...
 
 class NonCallableMagicMock(MagicMixin, NonCallableMock): ...
@@ -395,7 +395,7 @@ class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock):
     # But, `NonCallableMock` super-class has the better version.
     def reset_mock(self, visited: Any = None, *, return_value: bool = False, side_effect: bool = False) -> None: ...
 
-class MagicProxy:
+class MagicProxy(Base):
     name: str
     parent: Any
     def __init__(self, name: str, parent: Any) -> None: ...