basedpyright 1.22.0 → 1.22.1

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

@@ -10,13 +10,11 @@ from _ctypes import (
     _CanCastTo as _CanCastTo,
     _CArgObject as _CArgObject,
     _CData as _CData,
-    _CDataMeta as _CDataMeta,
+    _CDataType as _CDataType,
     _CField as _CField,
     _Pointer as _Pointer,
     _PointerLike as _PointerLike,
     _SimpleCData as _SimpleCData,
-    _StructUnionBase as _StructUnionBase,
-    _StructUnionMeta as _StructUnionMeta,
     addressof as addressof,
     alignment as alignment,
     byref as byref,
@@ -28,7 +26,7 @@ from _ctypes import (
 )
 from ctypes._endian import BigEndianStructure as BigEndianStructure, LittleEndianStructure as LittleEndianStructure
 from typing import Any, ClassVar, Generic, TypeVar
-from typing_extensions import TypeAlias
+from typing_extensions import Self, TypeAlias, deprecated
 
 if sys.platform == "win32":
     from _ctypes import FormatError as FormatError, get_last_error as get_last_error, set_last_error as set_last_error
@@ -41,6 +39,7 @@ if sys.version_info >= (3, 9):
 
 _T = TypeVar("_T")
 _DLLT = TypeVar("_DLLT", bound=CDLL)
+_CT = TypeVar("_CT", bound=_CData)
 
 DEFAULT_MODE: int
 
@@ -48,7 +47,7 @@ class ArgumentError(Exception): ...
 
 class CDLL:
     _func_flags_: ClassVar[int]
-    _func_restype_: ClassVar[_CData]
+    _func_restype_: ClassVar[_CDataType]
     _name: str
     _handle: int
     _FuncPtr: type[_FuncPointer]
@@ -97,15 +96,21 @@ class _NamedFuncPointer(_FuncPointer):
     __name__: str
 
 def CFUNCTYPE(
-    restype: type[_CData] | None, *argtypes: type[_CData], use_errno: bool = ..., use_last_error: bool = ...
+    restype: type[_CData | _CDataType] | None,
+    *argtypes: type[_CData | _CDataType],
+    use_errno: bool = ...,
+    use_last_error: bool = ...,
 ) -> type[_FuncPointer]: ...
 
 if sys.platform == "win32":
     def WINFUNCTYPE(
-        restype: type[_CData] | None, *argtypes: type[_CData], use_errno: bool = ..., use_last_error: bool = ...
+        restype: type[_CData | _CDataType] | None,
+        *argtypes: type[_CData | _CDataType],
+        use_errno: bool = ...,
+        use_last_error: bool = ...,
     ) -> type[_FuncPointer]: ...
 
-def PYFUNCTYPE(restype: type[_CData] | None, *argtypes: type[_CData]) -> type[_FuncPointer]: ...
+def PYFUNCTYPE(restype: type[_CData | _CDataType] | None, *argtypes: type[_CData | _CDataType]) -> type[_FuncPointer]: ...
 
 # Any type that can be implicitly converted to c_void_p when passed as a C function argument.
 # (bytes is not included here, see below.)
@@ -118,12 +123,17 @@ _CVoidConstPLike: TypeAlias = _CVoidPLike | bytes
 
 _CastT = TypeVar("_CastT", bound=_CanCastTo)
 
-def cast(obj: _CData | _CArgObject | int, typ: type[_CastT]) -> _CastT: ...
+def cast(obj: _CData | _CDataType | _CArgObject | int, typ: type[_CastT]) -> _CastT: ...
 def create_string_buffer(init: int | bytes, size: int | None = None) -> Array[c_char]: ...
 
 c_buffer = create_string_buffer
 
 def create_unicode_buffer(init: int | str, size: int | None = None) -> Array[c_wchar]: ...
+@deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
+def SetPointerType(
+    pointer: type[_Pointer[Any]], cls: Any  # noqa: F811  # Redefinition of unused `pointer` from line 22
+) -> None: ...
+def ARRAY(typ: _CT, len: int) -> Array[_CT]: ...  # Soft Deprecated, no plans to remove
 
 if sys.platform == "win32":
     def DllCanUnloadNow() -> int: ...
@@ -132,12 +142,12 @@ if sys.platform == "win32":
 
 def memmove(dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> int: ...
 def memset(dst: _CVoidPLike, c: int, count: int) -> int: ...
-def string_at(address: _CVoidConstPLike, size: int = -1) -> bytes: ...
+def string_at(ptr: _CVoidConstPLike, size: int = -1) -> bytes: ...
 
 if sys.platform == "win32":
     def WinError(code: int | None = None, descr: str | None = None) -> OSError: ...
 
-def wstring_at(address: _CVoidConstPLike, size: int = -1) -> str: ...
+def wstring_at(ptr: _CVoidConstPLike, size: int = -1) -> str: ...
 
 class c_byte(_SimpleCData[int]): ...
 
@@ -146,6 +156,8 @@ class c_char(_SimpleCData[bytes]):
 
 class c_char_p(_PointerLike, _SimpleCData[bytes | None]):
     def __init__(self, value: int | bytes | None = ...) -> None: ...
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
 
 class c_double(_SimpleCData[float]): ...
 class c_longdouble(_SimpleCData[float]): ...  # can be an alias for c_double
@@ -161,7 +173,13 @@ class c_uint(_SimpleCData[int]): ...  # can be an alias for c_ulong
 class c_ulong(_SimpleCData[int]): ...
 class c_ulonglong(_SimpleCData[int]): ...  # can be an alias for c_ulong
 class c_ushort(_SimpleCData[int]): ...
-class c_void_p(_PointerLike, _SimpleCData[int | None]): ...
+
+class c_void_p(_PointerLike, _SimpleCData[int | None]):
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
+
+c_voidp = c_void_p  # backwards compatibility (to a bug)
+
 class c_wchar(_SimpleCData[str]): ...
 
 c_int8 = c_byte
@@ -180,6 +198,8 @@ class c_uint64(_SimpleCData[int]): ...
 
 class c_wchar_p(_PointerLike, _SimpleCData[str | None]):
     def __init__(self, value: int | str | None = ...) -> None: ...
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
 
 class c_bool(_SimpleCData[bool]):
     def __init__(self, value: bool = ...) -> None: ...

package/dist/typeshed-fallback/stdlib/ctypes/macholib/__init__.pyi

@@ -0,0 +1 @@
+__version__: str

package/dist/typeshed-fallback/stdlib/ctypes/macholib/dyld.pyi

@@ -0,0 +1,8 @@
+from collections.abc import Mapping
+from ctypes.macholib.dylib import dylib_info as dylib_info
+from ctypes.macholib.framework import framework_info as framework_info
+
+__all__ = ["dyld_find", "framework_find", "framework_info", "dylib_info"]
+
+def dyld_find(name: str, executable_path: str | None = None, env: Mapping[str, str] | None = None) -> str: ...
+def framework_find(fn: str, executable_path: str | None = None, env: Mapping[str, str] | None = None) -> str: ...

package/dist/typeshed-fallback/stdlib/ctypes/macholib/dylib.pyi

@@ -0,0 +1,14 @@
+from typing import TypedDict, type_check_only
+
+__all__ = ["dylib_info"]
+
+# Actual result is produced by re.match.groupdict()
+@type_check_only
+class _DylibInfo(TypedDict):
+    location: str
+    name: str
+    shortname: str
+    version: str | None
+    suffix: str | None
+
+def dylib_info(filename: str) -> _DylibInfo | None: ...

package/dist/typeshed-fallback/stdlib/ctypes/macholib/framework.pyi

@@ -0,0 +1,14 @@
+from typing import TypedDict, type_check_only
+
+__all__ = ["framework_info"]
+
+# Actual result is produced by re.match.groupdict()
+@type_check_only
+class _FrameworkInfo(TypedDict):
+    location: str
+    name: str
+    shortname: str
+    version: str | None
+    suffix: str | None
+
+def framework_info(filename: str) -> _FrameworkInfo | None: ...

package/dist/typeshed-fallback/stdlib/ctypes/util.pyi

@@ -4,3 +4,5 @@ def find_library(name: str) -> str | None: ...
 
 if sys.platform == "win32":
     def find_msvcrt() -> str | None: ...
+
+def test() -> None: ...

package/dist/typeshed-fallback/stdlib/ctypes/wintypes.pyi

@@ -1,7 +1,7 @@
+from _ctypes import _CArgObject, _CField
 from ctypes import (
     Array,
     Structure,
-    _CField,
     _Pointer,
     _SimpleCData,
     c_byte,
@@ -21,8 +21,8 @@ from ctypes import (
     c_wchar,
     c_wchar_p,
 )
-from typing import TypeVar
-from typing_extensions import TypeAlias
+from typing import Any, TypeVar
+from typing_extensions import Self, TypeAlias
 
 BYTE = c_byte
 WORD = c_ushort
@@ -241,10 +241,16 @@ LPBYTE = PBYTE
 PBOOLEAN = PBYTE
 
 # LP_c_char
-class PCHAR(_Pointer[CHAR]): ...
+class PCHAR(_Pointer[CHAR]):
+    # this is inherited from ctypes.c_char_p, kind of.
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
 
 # LP_c_wchar
-class PWCHAR(_Pointer[WCHAR]): ...
+class PWCHAR(_Pointer[WCHAR]):
+    # inherited from ctypes.c_wchar_p, kind of
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
 
 # LP_c_void_p
 class PHANDLE(_Pointer[HANDLE]): ...

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

@@ -1,7 +1,9 @@
+import sys
 from _curses import *
 from _curses import window as window
+from _typeshed import structseq
 from collections.abc import Callable
-from typing import TypeVar
+from typing import Final, TypeVar, final, type_check_only
 from typing_extensions import Concatenate, ParamSpec
 
 # NOTE: The _curses module is ordinarily only available on Unix, but the
@@ -25,3 +27,19 @@ def wrapper(func: Callable[Concatenate[window, _P], _T], /, *arg: _P.args, **kwd
 # it was mapped to the name 'window' in 3.8.
 # Kept here as a legacy alias in case any third-party code is relying on it.
 _CursesWindow = window
+
+# At runtime this class is unexposed and calls itself curses.ncurses_version.
+# That name would conflict with the actual curses.ncurses_version, which is
+# an instance of this class.
+@final
+@type_check_only
+class _ncurses_version(structseq[int], tuple[int, int, int]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("major", "minor", "patch")
+
+    @property
+    def major(self) -> int: ...
+    @property
+    def minor(self) -> int: ...
+    @property
+    def patch(self) -> int: ...

package/dist/typeshed-fallback/stdlib/curses/panel.pyi

@@ -1,34 +1 @@
-from _curses import window
-
-version: str
-
-class _Curses_Panel:  # type is <class '_curses_panel.curses panel'> (note the space in the class name)
-    def above(self) -> _Curses_Panel: ...
-    def below(self) -> _Curses_Panel: ...
-    def bottom(self) -> None: ...
-    def hidden(self) -> bool: ...
-    def hide(self) -> None: ...
-    def move(self, y: int, x: int) -> None: ...
-    def replace(self, win: window) -> None: ...
-    def set_userptr(self, obj: object) -> None: ...
-    def show(self) -> None: ...
-    def top(self) -> None: ...
-    def userptr(self) -> object: ...
-    def window(self) -> window: ...
-
-def bottom_panel() -> _Curses_Panel:
-    """Return the bottom panel in the panel stack."""
-    ...
-def new_panel(win: window, /) -> _Curses_Panel:
-    """Return a panel object, associating it with the given window win."""
-    ...
-def top_panel() -> _Curses_Panel:
-    """Return the top panel in the panel stack."""
-    ...
-def update_panels() -> _Curses_Panel:
-    """
-    Updates the virtual screen after changes in the panel stack.
-
-    This does not call curses.doupdate(), so you'll have to do this yourself.
-    """
-    ...
+from _curses_panel import *

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

@@ -1,8 +1,8 @@
 import sys
 from abc import abstractmethod
 from time import struct_time
-from typing import ClassVar, Final, NamedTuple, NoReturn, SupportsIndex, final, overload
-from typing_extensions import Self, TypeAlias, deprecated
+from typing import ClassVar, Final, NoReturn, SupportsIndex, final, overload, type_check_only
+from typing_extensions import CapsuleType, Self, TypeAlias, deprecated
 
 if sys.version_info >= (3, 11):
     __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo", "MINYEAR", "MAXYEAR", "UTC")
@@ -58,10 +58,17 @@ if sys.version_info >= (3, 11):
     UTC: timezone
 
 if sys.version_info >= (3, 9):
-    class _IsoCalendarDate(NamedTuple):
-        year: int
-        week: int
-        weekday: int
+    # This class calls itself datetime.IsoCalendarDate. It's neither
+    # NamedTuple nor structseq.
+    @final
+    @type_check_only
+    class _IsoCalendarDate(tuple[int, int, int]):
+        @property
+        def year(self) -> int: ...
+        @property
+        def week(self) -> int: ...
+        @property
+        def weekday(self) -> int: ...
 
 class date:
     min: ClassVar[date]
@@ -573,3 +580,5 @@ class datetime(date):
     def __sub__(self, value: timedelta, /) -> Self:
         """Return self-value."""
         ...
+
+datetime_CAPI: CapsuleType

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

@@ -2,7 +2,7 @@ import sys
 from _typeshed import StrOrBytesPath
 from collections.abc import Iterator, MutableMapping
 from types import TracebackType
-from typing import Literal
+from typing import Literal, type_check_only
 from typing_extensions import Self, TypeAlias
 
 __all__ = ["open", "whichdb", "error"]
@@ -89,6 +89,8 @@ class _Database(MutableMapping[_KeyType, bytes]):
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
 
+# This class is not exposed. It calls itself dbm.error.
+@type_check_only
 class _error(Exception): ...
 
 error: tuple[type[_error], type[OSError]]

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

@@ -24,7 +24,8 @@ from _decimal import (
     setcontext as setcontext,
 )
 from collections.abc import Container, Sequence
-from typing import Any, ClassVar, Literal, NamedTuple, overload
+from types import TracebackType
+from typing import Any, ClassVar, Literal, NamedTuple, final, overload, type_check_only
 from typing_extensions import Self, TypeAlias
 
 _Decimal: TypeAlias = Decimal | int
@@ -35,6 +36,14 @@ _TrapType: TypeAlias = type[DecimalException]
 # At runtime, these classes are implemented in C as part of "_decimal".
 # However, they consider themselves to live in "decimal", so we'll put them here.
 
+# This type isn't exposed at runtime. It calls itself decimal.ContextManager
+@final
+@type_check_only
+class _ContextManager:
+    def __init__(self, new_context: Context) -> None: ...
+    def __enter__(self) -> Context: ...
+    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+
 class DecimalTuple(NamedTuple):
     sign: int
     digits: tuple[int, ...]

package/dist/typeshed-fallback/stdlib/distutils/ccompiler.pyi

@@ -165,7 +165,7 @@ class CCompiler:
     def execute(
         self, func: Callable[[Unpack[_Ts]], Unused], args: tuple[Unpack[_Ts]], msg: str | None = None, level: int = 1
     ) -> None: ...
-    def spawn(self, cmd: list[str]) -> None: ...
+    def spawn(self, cmd: Iterable[str]) -> None: ...
     def mkpath(self, name: str, mode: int = 0o777) -> None: ...
     @overload
     def move_file(self, src: StrPath, dst: _StrPathT) -> _StrPathT | str: ...

package/dist/typeshed-fallback/stdlib/distutils/spawn.pyi

@@ -1,6 +1,10 @@
+from collections.abc import Iterable
 from typing import Literal
 
 def spawn(
-    cmd: list[str], search_path: bool | Literal[0, 1] = 1, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0
+    cmd: Iterable[str],
+    search_path: bool | Literal[0, 1] = 1,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
 ) -> None: ...
 def find_executable(executable: str, path: str | None = None) -> str | None: ...

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

@@ -3,7 +3,7 @@ import types
 import unittest
 from _typeshed import ExcInfo
 from collections.abc import Callable
-from typing import Any, ClassVar, NamedTuple
+from typing import Any, NamedTuple, type_check_only
 from typing_extensions import Self, TypeAlias
 
 __all__ = [
@@ -42,17 +42,15 @@ __all__ = [
     "debug",
 ]
 
-# MyPy errors on conditionals within named tuples.
-
 if sys.version_info >= (3, 13):
-    class TestResults(NamedTuple):
-        def __new__(cls, failed: int, attempted: int, *, skipped: int = 0) -> Self: ...  # type: ignore[misc]
-        skipped: int
+    @type_check_only
+    class _TestResultsBase(NamedTuple):
         failed: int
         attempted: int
-        _fields: ClassVar = ("failed", "attempted")  # type: ignore[misc]
-        __match_args__ = ("failed", "attempted")  # type: ignore[misc]
-        __doc__: None  # type: ignore[misc]
+
+    class TestResults(_TestResultsBase):
+        def __new__(cls, failed: int, attempted: int, *, skipped: int = 0) -> Self: ...
+        skipped: int
 
 else:
     class TestResults(NamedTuple):

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

@@ -4,6 +4,29 @@ from email.policy import Policy
 from typing import IO
 from typing_extensions import TypeAlias
 
+# At runtime, listing submodules in __all__ without them being imported is
+# valid, and causes them to be included in a star import. See #6523
+
+__all__ = [  # noqa: F822  # Undefined names in __all__
+    "base64mime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "charset",  # pyright: ignore[reportUnsupportedDunderAll]
+    "encoders",  # pyright: ignore[reportUnsupportedDunderAll]
+    "errors",  # pyright: ignore[reportUnsupportedDunderAll]
+    "feedparser",  # pyright: ignore[reportUnsupportedDunderAll]
+    "generator",  # pyright: ignore[reportUnsupportedDunderAll]
+    "header",  # pyright: ignore[reportUnsupportedDunderAll]
+    "iterators",  # pyright: ignore[reportUnsupportedDunderAll]
+    "message",  # pyright: ignore[reportUnsupportedDunderAll]
+    "message_from_file",
+    "message_from_binary_file",
+    "message_from_string",
+    "message_from_bytes",
+    "mime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "parser",  # pyright: ignore[reportUnsupportedDunderAll]
+    "quoprimime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "utils",  # pyright: ignore[reportUnsupportedDunderAll]
+]
+
 # Definitions imported by multiple submodules in typeshed
 _ParamType: TypeAlias = str | tuple[str | None, str | None, str]  # noqa: Y047
 _ParamsType: TypeAlias = str | None | tuple[str, str | None, str]  # noqa: Y047
@@ -12,18 +35,3 @@ def message_from_string(s: str, _class: Callable[[], Message] = ..., *, policy:
 def message_from_bytes(s: bytes | bytearray, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
 def message_from_file(fp: IO[str], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
 def message_from_binary_file(fp: IO[bytes], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
-
-# Names in __all__ with no definition:
-#   base64mime
-#   charset
-#   encoders
-#   errors
-#   feedparser
-#   generator
-#   header
-#   iterators
-#   message
-#   mime
-#   parser
-#   quoprimime
-#   utils

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

@@ -5,6 +5,8 @@ from email.message import Message
 from typing import Generic, Protocol, TypeVar, type_check_only
 from typing_extensions import Self
 
+__all__ = ["Policy", "Compat32", "compat32"]
+
 _MessageT = TypeVar("_MessageT", bound=Message, default=Message)
 
 @type_check_only

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

@@ -0,0 +1 @@
+aliases: dict[str, str]

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

@@ -0,0 +1,30 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.ascii_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.ascii_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+# Note: encode being a decode function and decode being an encode function is accurate to runtime.
+class StreamConverter(StreamWriter, StreamReader):  # type: ignore[misc]  # incompatible methods in base classes
+    # At runtime, this is codecs.ascii_decode
+    @staticmethod
+    def encode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...  # type: ignore[override]
+    # At runtime, this is codecs.ascii_encode
+    @staticmethod
+    def decode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...

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

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def base64_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def base64_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/big5.pyi

@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

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

@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

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

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def bz2_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def bz2_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/charmap.pyi

@@ -0,0 +1,33 @@
+import codecs
+from _codecs import _CharMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.charmap_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, mapping: _CharMap | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.charmap_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, mapping: _CharMap | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    mapping: _CharMap | None
+    def __init__(self, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    mapping: _CharMap | None
+    def __init__(self, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    mapping: _CharMap | None
+    def __init__(self, stream: codecs._WritableStream, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class StreamReader(Codec, codecs.StreamReader):
+    mapping: _CharMap | None
+    def __init__(self, stream: codecs._ReadableStream, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...