basedpyright 1.22.0 → 1.22.1

package/dist/typeshed-fallback/stdlib/encodings/utf_7.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_7_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_7_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_7_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_7_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_8.pyi

@@ -1,21 +1,26 @@
 import codecs
 from _typeshed import ReadableBuffer
 
+encode = codecs.utf_8_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
 class IncrementalEncoder(codecs.IncrementalEncoder):
     def encode(self, input: str, final: bool = False) -> bytes: ...
 
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_8_decode
     @staticmethod
     def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
 
 class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_8_encode
     @staticmethod
     def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
 
 class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_8_decode
     @staticmethod
     def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
 
 def getregentry() -> codecs.CodecInfo: ...
-def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
-def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...

package/dist/typeshed-fallback/stdlib/encodings/uu_codec.pyi

@@ -0,0 +1,28 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def uu_encode(
+    input: ReadableBuffer, errors: str = "strict", filename: str = "<data>", mode: int = 0o666
+) -> tuple[bytes, int]: ...
+def uu_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/zlib_codec.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def zlib_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def zlib_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

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

@@ -77,8 +77,10 @@ if sys.platform != "win32":
         LOCK_RW: int
         LOCK_WRITE: int
 
-    # These are highly problematic, they might be present or not, depends on the specific OS.
     if sys.platform == "linux":
+        # Constants for the POSIX STREAMS interface. Present in glibc until 2.29 (released February 2019).
+        # Never implemented on BSD, and considered "obsolescent" starting in POSIX 2008.
+        # Probably still used on Solaris.
         I_ATMARK: int
         I_CANPUT: int
         I_CKBAND: int

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

@@ -167,3 +167,5 @@ if sys.version_info < (3, 11):
     def bind_textdomain_codeset(domain: str, codeset: str | None = None) -> str: ...
 
 Catalog = translation
+
+def c2py(plural: str) -> Callable[[int], int]: ...

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

@@ -1,9 +1,19 @@
 import sys
 from _blake2 import blake2b as blake2b, blake2s as blake2s
+from _hashlib import (
+    HASH,
+    openssl_md5 as md5,
+    openssl_sha1 as sha1,
+    openssl_sha224 as sha224,
+    openssl_sha256 as sha256,
+    openssl_sha384 as sha384,
+    openssl_sha512 as sha512,
+    pbkdf2_hmac as pbkdf2_hmac,
+    scrypt as scrypt,
+)
 from _typeshed import ReadableBuffer
 from collections.abc import Callable, Set as AbstractSet
-from typing import Protocol
-from typing_extensions import Self
+from typing import Protocol, type_check_only
 
 if sys.version_info >= (3, 11):
     __all__ = (
@@ -49,107 +59,35 @@ else:
         "pbkdf2_hmac",
     )
 
-class _Hash:
-    @property
-    def digest_size(self) -> int: ...
-    @property
-    def block_size(self) -> int: ...
-    @property
-    def name(self) -> str: ...
-    def copy(self) -> Self: ...
-    def digest(self) -> bytes: ...
-    def hexdigest(self) -> str: ...
-    def update(self, data: ReadableBuffer, /) -> None: ...
-
-class _VarLenHash:
-    digest_size: int
-    block_size: int
-    name: str
-    def copy(self) -> _VarLenHash: ...
-    def digest(self, length: int, /) -> bytes: ...
-    def hexdigest(self, length: int, /) -> str: ...
-    def update(self, data: ReadableBuffer, /) -> None: ...
-
 if sys.version_info >= (3, 9):
-    def new(name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...) -> _Hash: ...
-    def md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a md5 hash object; optionally initialized with a string"""
-        ...
-    def sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha1 hash object; optionally initialized with a string"""
-        ...
-    def sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha224 hash object; optionally initialized with a string"""
-        ...
-    def sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha256 hash object; optionally initialized with a string"""
-        ...
-    def sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha384 hash object; optionally initialized with a string"""
-        ...
-    def sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha512 hash object; optionally initialized with a string"""
-        ...
-    def sha3_224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha3-224 hash object; optionally initialized with a string"""
-        ...
-    def sha3_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha3-256 hash object; optionally initialized with a string"""
-        ...
-    def sha3_384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha3-384 hash object; optionally initialized with a string"""
-        ...
-    def sha3_512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash:
-        """Returns a sha3-512 hash object; optionally initialized with a string"""
-        ...
-    def shake_128(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _VarLenHash:
-        """Returns a shake-128 variable hash object; optionally initialized with a string"""
-        ...
-    def shake_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _VarLenHash:
-        """Returns a shake-256 variable hash object; optionally initialized with a string"""
-        ...
+    def new(name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...) -> HASH: ...
+    from _hashlib import (
+        openssl_sha3_224 as sha3_224,
+        openssl_sha3_256 as sha3_256,
+        openssl_sha3_384 as sha3_384,
+        openssl_sha3_512 as sha3_512,
+        openssl_shake_128 as shake_128,
+        openssl_shake_256 as shake_256,
+    )
 
 else:
-    def new(name: str, data: ReadableBuffer = b"") -> _Hash: ...
-    def md5(string: ReadableBuffer = b"") -> _Hash:
-        """Returns a md5 hash object; optionally initialized with a string"""
-        ...
-    def sha1(string: ReadableBuffer = b"") -> _Hash:
-        """Returns a sha1 hash object; optionally initialized with a string"""
-        ...
-    def sha224(string: ReadableBuffer = b"") -> _Hash:
-        """Returns a sha224 hash object; optionally initialized with a string"""
-        ...
-    def sha256(string: ReadableBuffer = b"") -> _Hash:
-        """Returns a sha256 hash object; optionally initialized with a string"""
-        ...
-    def sha384(string: ReadableBuffer = b"") -> _Hash:
-        """Returns a sha384 hash object; optionally initialized with a string"""
-        ...
-    def sha512(string: ReadableBuffer = b"") -> _Hash:
-        """Returns a sha512 hash object; optionally initialized with a string"""
-        ...
-    def sha3_224(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha3_256(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha3_384(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha3_512(string: ReadableBuffer = b"") -> _Hash: ...
+    @type_check_only
+    class _VarLenHash(HASH):
+        def digest(self, length: int) -> bytes: ...  # type: ignore[override]
+        def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
+
+    def new(name: str, data: ReadableBuffer = b"") -> HASH: ...
+    # At runtime these aren't functions but classes imported from _sha3
+    def sha3_224(string: ReadableBuffer = b"") -> HASH: ...
+    def sha3_256(string: ReadableBuffer = b"") -> HASH: ...
+    def sha3_384(string: ReadableBuffer = b"") -> HASH: ...
+    def sha3_512(string: ReadableBuffer = b"") -> HASH: ...
     def shake_128(string: ReadableBuffer = b"") -> _VarLenHash: ...
     def shake_256(string: ReadableBuffer = b"") -> _VarLenHash: ...
 
 algorithms_guaranteed: AbstractSet[str]
 algorithms_available: AbstractSet[str]
 
-def pbkdf2_hmac(
-    hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: int | None = None
-) -> bytes:
-    """Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function."""
-    ...
-def scrypt(
-    password: ReadableBuffer, *, salt: ReadableBuffer, n: int, r: int, p: int, maxmem: int = 0, dklen: int = 64
-) -> bytes:
-    """scrypt password-based key derivation function."""
-    ...
-
 if sys.version_info >= (3, 11):
     class _BytesIOLike(Protocol):
         def getbuffer(self) -> ReadableBuffer: ...
@@ -159,5 +97,8 @@ if sys.version_info >= (3, 11):
         def readable(self) -> bool: ...
 
     def file_digest(
-        fileobj: _BytesIOLike | _FileDigestFileObj, digest: str | Callable[[], _Hash], /, *, _bufsize: int = 262144
-    ) -> _Hash: ...
+        fileobj: _BytesIOLike | _FileDigestFileObj, digest: str | Callable[[], HASH], /, *, _bufsize: int = 262144
+    ) -> HASH: ...
+
+# Legacy typing-only alias
+_Hash = HASH

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

@@ -1,6 +1,7 @@
+import sys
+from _hashlib import HASH as _HashlibHash
 from _typeshed import ReadableBuffer, SizedBuffer
 from collections.abc import Callable
-from hashlib import _Hash as _HashlibHash
 from types import ModuleType
 from typing import AnyStr, overload
 from typing_extensions import TypeAlias
@@ -30,36 +31,40 @@ class HMAC:
     def hexdigest(self) -> str: ...
     def copy(self) -> HMAC: ...
 
-@overload
-def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool:
-    """
-    Return 'a == b'.
+def digest(key: SizedBuffer, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
 
-    This function uses an approach designed to prevent
-    timing analysis, making it appropriate for cryptography.
+if sys.version_info >= (3, 9):
+    from _hashlib import compare_digest as compare_digest
+else:
+    @overload
+    def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool:
+        """
+        Return 'a == b'.
 
-    a and b must both be of the same type: either str (ASCII only),
-    or any bytes-like object.
+        This function uses an approach designed to prevent
+        timing analysis, making it appropriate for cryptography.
 
-    Note: If a and b are of different lengths, or if an error occurs,
-    a timing attack could theoretically reveal information about the
-    types and lengths of a and b--but not their values.
-    """
-    ...
-@overload
-def compare_digest(a: AnyStr, b: AnyStr, /) -> bool:
-    """
-    Return 'a == b'.
+        a and b must both be of the same type: either str (ASCII only),
+        or any bytes-like object.
 
-    This function uses an approach designed to prevent
-    timing analysis, making it appropriate for cryptography.
+        Note: If a and b are of different lengths, or if an error occurs,
+        a timing attack could theoretically reveal information about the
+        types and lengths of a and b--but not their values.
+        """
+        ...
+    @overload
+    def compare_digest(a: AnyStr, b: AnyStr, /) -> bool:
+        """
+        Return 'a == b'.
 
-    a and b must both be of the same type: either str (ASCII only),
-    or any bytes-like object.
+        This function uses an approach designed to prevent
+        timing analysis, making it appropriate for cryptography.
 
-    Note: If a and b are of different lengths, or if an error occurs,
-    a timing attack could theoretically reveal information about the
-    types and lengths of a and b--but not their values.
-    """
-    ...
-def digest(key: SizedBuffer, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
+        a and b must both be of the same type: either str (ASCII only),
+        or any bytes-like object.
+
+        Note: If a and b are of different lengths, or if an error occurs,
+        a timing attack could theoretically reveal information about the
+        types and lengths of a and b--but not their values.
+        """
+        ...

package/dist/typeshed-fallback/stdlib/importlib/resources/abc.pyi

@@ -10,3 +10,5 @@ if sys.version_info >= (3, 11):
         Traversable as Traversable,
         TraversableResources as TraversableResources,
     )
+
+    __all__ = ["ResourceReader", "Traversable", "TraversableResources"]

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

@@ -63,25 +63,6 @@ class _BaseAddress(_IPAddressBase):
         def __gt__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
         def __le__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
 
-    @property
-    def is_global(self) -> bool: ...
-    @property
-    def is_link_local(self) -> bool: ...
-    @property
-    def is_loopback(self) -> bool: ...
-    @property
-    def is_multicast(self) -> bool: ...
-    @property
-    def is_private(self) -> bool: ...
-    @property
-    def is_reserved(self) -> bool: ...
-    @property
-    def is_unspecified(self) -> bool: ...
-    @property
-    def max_prefixlen(self) -> int: ...
-    @property
-    def packed(self) -> bytes: ...
-
 class _BaseNetwork(_IPAddressBase, Generic[_A]):
     network_address: _A
     netmask: _A
@@ -176,8 +157,6 @@ class _BaseNetwork(_IPAddressBase, Generic[_A]):
         """
         ...
     @property
-    def max_prefixlen(self) -> int: ...
-    @property
     def num_addresses(self) -> int:
         """Number of hosts in the current subnet."""
         ...
@@ -204,6 +183,93 @@ class _BaseV4:
     def max_prefixlen(self) -> Literal[32]: ...
 
 class IPv4Address(_BaseV4, _BaseAddress):
+    @property
+    def is_global(self) -> bool:
+        """
+        ``True`` if the address is defined as globally reachable by
+        iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
+        (for IPv6) with the following exception:
+
+        For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
+        semantics of the underlying IPv4 addresses and the following condition holds
+        (see :attr:`IPv6Address.ipv4_mapped`)::
+
+            address.is_global == address.ipv4_mapped.is_global
+
+        ``is_global`` has value opposite to :attr:`is_private`, except for the ``100.64.0.0/10``
+        IPv4 range where they are both ``False``.
+        """
+        ...
+    @property
+    def is_link_local(self) -> bool:
+        """
+        Test if the address is reserved for link-local.
+
+        Returns:
+            A boolean, True if the address is link-local per RFC 3927.
+        """
+        ...
+    @property
+    def is_loopback(self) -> bool:
+        """
+        Test if the address is a loopback address.
+
+        Returns:
+            A boolean, True if the address is a loopback per RFC 3330.
+        """
+        ...
+    @property
+    def is_multicast(self) -> bool:
+        """
+        Test if the address is reserved for multicast use.
+
+        Returns:
+            A boolean, True if the address is multicast.
+            See RFC 3171 for details.
+        """
+        ...
+    @property
+    def is_private(self) -> bool:
+        """
+        ``True`` if the address is defined as not globally reachable by
+        iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
+        (for IPv6) with the following exceptions:
+
+        * ``is_private`` is ``False`` for ``100.64.0.0/10``
+        * For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
+            semantics of the underlying IPv4 addresses and the following condition holds
+            (see :attr:`IPv6Address.ipv4_mapped`)::
+
+                address.is_private == address.ipv4_mapped.is_private
+
+        ``is_private`` has value opposite to :attr:`is_global`, except for the ``100.64.0.0/10``
+        IPv4 range where they are both ``False``.
+        """
+        ...
+    @property
+    def is_reserved(self) -> bool:
+        """
+        Test if the address is otherwise IETF reserved.
+
+        Returns:
+            A boolean, True if the address is within the
+            reserved IPv4 Network range.
+        """
+        ...
+    @property
+    def is_unspecified(self) -> bool:
+        """
+        Test if the address is unspecified.
+
+        Returns:
+            A boolean, True if this is the unspecified address as defined in
+            RFC 5735 3.
+        """
+        ...
+    @property
+    def packed(self) -> bytes:
+        """The binary representation of this address."""
+        ...
     if sys.version_info >= (3, 13):
         @property
         def ipv6_mapped(self) -> IPv6Address:
@@ -241,6 +307,94 @@ class _BaseV6:
 
 class IPv6Address(_BaseV6, _BaseAddress):
     @property
+    def is_global(self) -> bool:
+        """
+        ``True`` if the address is defined as globally reachable by
+        iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
+        (for IPv6) with the following exception:
+
+        For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
+        semantics of the underlying IPv4 addresses and the following condition holds
+        (see :attr:`IPv6Address.ipv4_mapped`)::
+
+            address.is_global == address.ipv4_mapped.is_global
+
+        ``is_global`` has value opposite to :attr:`is_private`, except for the ``100.64.0.0/10``
+        IPv4 range where they are both ``False``.
+        """
+        ...
+    @property
+    def is_link_local(self) -> bool:
+        """
+        Test if the address is reserved for link-local.
+
+        Returns:
+            A boolean, True if the address is reserved per RFC 4291.
+        """
+        ...
+    @property
+    def is_loopback(self) -> bool:
+        """
+        Test if the address is a loopback address.
+
+        Returns:
+            A boolean, True if the address is a loopback address as defined in
+            RFC 2373 2.5.3.
+        """
+        ...
+    @property
+    def is_multicast(self) -> bool:
+        """
+        Test if the address is reserved for multicast use.
+
+        Returns:
+            A boolean, True if the address is a multicast address.
+            See RFC 2373 2.7 for details.
+        """
+        ...
+    @property
+    def is_private(self) -> bool:
+        """
+        ``True`` if the address is defined as not globally reachable by
+        iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
+        (for IPv6) with the following exceptions:
+
+        * ``is_private`` is ``False`` for ``100.64.0.0/10``
+        * For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
+            semantics of the underlying IPv4 addresses and the following condition holds
+            (see :attr:`IPv6Address.ipv4_mapped`)::
+
+                address.is_private == address.ipv4_mapped.is_private
+
+        ``is_private`` has value opposite to :attr:`is_global`, except for the ``100.64.0.0/10``
+        IPv4 range where they are both ``False``.
+        """
+        ...
+    @property
+    def is_reserved(self) -> bool:
+        """
+        Test if the address is otherwise IETF reserved.
+
+        Returns:
+            A boolean, True if the address is within one of the
+            reserved IPv6 Network ranges.
+        """
+        ...
+    @property
+    def is_unspecified(self) -> bool:
+        """
+        Test if the address is unspecified.
+
+        Returns:
+            A boolean, True if this is the unspecified address as defined in
+            RFC 2373 2.5.2.
+        """
+        ...
+    @property
+    def packed(self) -> bytes:
+        """The binary representation of this address."""
+        ...
+    @property
     def ipv4_mapped(self) -> IPv4Address | None:
         """
         Return the IPv4 mapped address.

package/dist/typeshed-fallback/stdlib/json/scanner.pyi

@@ -0,0 +1,3 @@
+from _json import make_scanner as make_scanner
+
+__all__ = ["make_scanner"]

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

@@ -64,3 +64,5 @@ class ModuleFinder:
     def any_missing(self) -> list[str]: ...  # undocumented
     def any_missing_maybe(self) -> tuple[list[str], list[str]]: ...  # undocumented
     def replace_paths_in_code(self, co: CodeType) -> CodeType: ...  # undocumented
+
+def test() -> ModuleFinder | None: ...  # undocumented

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

@@ -1,7 +1,8 @@
 import ctypes
 import sys
+from _ctypes import _CData
 from collections.abc import Callable, Iterable, Sequence
-from ctypes import _CData, _SimpleCData, c_char
+from ctypes import _SimpleCData, c_char
 from logging import Logger, _Level as _LoggingLevel
 from multiprocessing import popen_fork, popen_forkserver, popen_spawn_posix, popen_spawn_win32, queues, synchronize
 from multiprocessing.managers import SyncManager

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

@@ -1,6 +1,7 @@
 import ctypes
+from _ctypes import _CData
 from collections.abc import Callable, Iterable, Sequence
-from ctypes import _CData, _SimpleCData, c_char
+from ctypes import _SimpleCData, c_char
 from multiprocessing.context import BaseContext
 from multiprocessing.synchronize import _LockLike
 from types import TracebackType