basedpyright 1.12.6 → 1.13.0

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

@@ -1,3 +1,10 @@
+"""
+This module defines an object type which can efficiently represent
+an array of basic values: characters, integers, floating point
+numbers.  Arrays are sequence types and behave very much like lists,
+except that the type of objects stored in them is constrained.
+"""
+
 import sys
 from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
 from collections.abc import Iterable
@@ -19,10 +26,72 @@ _T = TypeVar("_T", int, float, str)
 typecodes: str
 
 class array(MutableSequence[_T]):
+    """
+    array(typecode [, initializer]) -> array
+
+    Return a new array whose items are restricted by typecode, and
+    initialized from the optional initializer value, which must be a list,
+    string or iterable over elements of the appropriate type.
+
+    Arrays represent basic values and behave very much like lists, except
+    the type of objects stored in them is constrained. The type is specified
+    at object creation time by using a type code, which is a single character.
+    The following type codes are defined:
+
+        Type code   C Type             Minimum size in bytes
+        'b'         signed integer     1
+        'B'         unsigned integer   1
+        'u'         Unicode character  2 (see note)
+        'h'         signed integer     2
+        'H'         unsigned integer   2
+        'i'         signed integer     2
+        'I'         unsigned integer   2
+        'l'         signed integer     4
+        'L'         unsigned integer   4
+        'q'         signed integer     8 (see note)
+        'Q'         unsigned integer   8 (see note)
+        'f'         floating point     4
+        'd'         floating point     8
+
+    NOTE: The 'u' typecode corresponds to Python's unicode character. On
+    narrow builds this is 2-bytes on wide builds this is 4-bytes.
+
+    NOTE: The 'q' and 'Q' type codes are only available if the platform
+    C compiler used to build Python supports 'long long', or, on Windows,
+    '__int64'.
+
+    Methods:
+
+    append() -- append a new item to the end of the array
+    buffer_info() -- return information giving the current memory info
+    byteswap() -- byteswap all the items of the array
+    count() -- return number of occurrences of an object
+    extend() -- extend array by appending multiple elements from an iterable
+    fromfile() -- read items from a file object
+    fromlist() -- append items from the list
+    frombytes() -- append items from the string
+    index() -- return index of first occurrence of an object
+    insert() -- insert a new item into the array at a provided position
+    pop() -- remove and return item (default last)
+    remove() -- remove first occurrence of an object
+    reverse() -- reverse the order of the items in the array
+    tofile() -- write all items to a file object
+    tolist() -- return the array converted to an ordinary list
+    tobytes() -- return the array converted to a string
+
+    Attributes:
+
+    typecode -- the typecode character used to create the array
+    itemsize -- the length in bytes of one array item
+    """
     @property
-    def typecode(self) -> _TypeCode: ...
+    def typecode(self) -> _TypeCode:
+        """the typecode character used to create the array"""
+        ...
     @property
-    def itemsize(self) -> int: ...
+    def itemsize(self) -> int:
+        """the size, in bytes, of one array item"""
+        ...
     @overload
     def __init__(self: array[int], typecode: _IntTypeCode, initializer: bytes | bytearray | Iterable[int] = ..., /) -> None: ...
     @overload
@@ -37,56 +106,176 @@ class array(MutableSequence[_T]):
     def __init__(self, typecode: str, initializer: Iterable[_T], /) -> None: ...
     @overload
     def __init__(self, typecode: str, initializer: bytes | bytearray = ..., /) -> None: ...
-    def append(self, v: _T, /) -> None: ...
-    def buffer_info(self) -> tuple[int, int]: ...
-    def byteswap(self) -> None: ...
-    def count(self, v: _T, /) -> int: ...
-    def extend(self, bb: Iterable[_T], /) -> None: ...
-    def frombytes(self, buffer: ReadableBuffer, /) -> None: ...
-    def fromfile(self, f: SupportsRead[bytes], n: int, /) -> None: ...
-    def fromlist(self, list: list[_T], /) -> None: ...
-    def fromunicode(self, ustr: str, /) -> None: ...
+    def append(self, v: _T, /) -> None:
+        """Append new value v to the end of the array."""
+        ...
+    def buffer_info(self) -> tuple[int, int]:
+        """
+        Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.
+
+        The length should be multiplied by the itemsize attribute to calculate
+        the buffer length in bytes.
+        """
+        ...
+    def byteswap(self) -> None:
+        """
+        Byteswap all items of the array.
+
+        If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is
+        raised.
+        """
+        ...
+    def count(self, v: _T, /) -> int:
+        """Return number of occurrences of v in the array."""
+        ...
+    def extend(self, bb: Iterable[_T], /) -> None:
+        """Append items to the end of the array."""
+        ...
+    def frombytes(self, buffer: ReadableBuffer, /) -> None:
+        """Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method)."""
+        ...
+    def fromfile(self, f: SupportsRead[bytes], n: int, /) -> None:
+        """Read n objects from the file object f and append them to the end of the array."""
+        ...
+    def fromlist(self, list: list[_T], /) -> None:
+        """Append items to array from list."""
+        ...
+    def fromunicode(self, ustr: str, /) -> None:
+        """
+        Extends this array with data from the unicode string ustr.
+
+        The array must be a unicode type array; otherwise a ValueError is raised.
+        Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of
+        some other type.
+        """
+        ...
     if sys.version_info >= (3, 10):
-        def index(self, v: _T, start: int = 0, stop: int = sys.maxsize, /) -> int: ...
+        def index(self, v: _T, start: int = 0, stop: int = sys.maxsize, /) -> int:
+            """
+            Return index of first occurrence of v in the array.
+
+            Raise ValueError if the value is not present.
+            """
+            ...
     else:
-        def index(self, v: _T, /) -> int: ...  # type: ignore[override]
-
-    def insert(self, i: int, v: _T, /) -> None: ...
-    def pop(self, i: int = -1, /) -> _T: ...
-    def remove(self, v: _T, /) -> None: ...
-    def tobytes(self) -> bytes: ...
-    def tofile(self, f: SupportsWrite[bytes], /) -> None: ...
-    def tolist(self) -> list[_T]: ...
-    def tounicode(self) -> str: ...
+        def index(self, v: _T, /) -> int:
+            """Return index of first occurrence of v in the array."""
+            ...
+
+    def insert(self, i: int, v: _T, /) -> None:
+        """Insert a new item v into the array before position i."""
+        ...
+    def pop(self, i: int = -1, /) -> _T:
+        """
+        Return the i-th element and delete it from the array.
+
+        i defaults to -1.
+        """
+        ...
+    def remove(self, v: _T, /) -> None:
+        """Remove the first occurrence of v in the array."""
+        ...
+    def tobytes(self) -> bytes:
+        """Convert the array to an array of machine values and return the bytes representation."""
+        ...
+    def tofile(self, f: SupportsWrite[bytes], /) -> None:
+        """Write all items (as machine values) to the file object f."""
+        ...
+    def tolist(self) -> list[_T]:
+        """Convert array to an ordinary list with the same items."""
+        ...
+    def tounicode(self) -> str:
+        """
+        Extends this array with data from the unicode string ustr.
+
+        Convert the array to a unicode string.  The array must be a unicode type array;
+        otherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a
+        unicode string from an array of some other type.
+        """
+        ...
     if sys.version_info < (3, 9):
-        def fromstring(self, buffer: str | ReadableBuffer, /) -> None: ...
-        def tostring(self) -> bytes: ...
+        def fromstring(self, buffer: str | ReadableBuffer, /) -> None:
+            """
+            Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method).
+
+            This method is deprecated. Use frombytes instead.
+            """
+            ...
+        def tostring(self) -> bytes:
+            """
+            Convert the array to an array of machine values and return the bytes representation.
+
+            This method is deprecated. Use tobytes instead.
+            """
+            ...
 
-    def __len__(self) -> int: ...
+    def __len__(self) -> int:
+        """Return len(self)."""
+        ...
     @overload
-    def __getitem__(self, key: SupportsIndex, /) -> _T: ...
+    def __getitem__(self, key: SupportsIndex, /) -> _T:
+        """Return self[key]."""
+        ...
     @overload
-    def __getitem__(self, key: slice, /) -> array[_T]: ...
+    def __getitem__(self, key: slice, /) -> array[_T]:
+        """Return self[key]."""
+        ...
     @overload  # type: ignore[override]
-    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...
+    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None:
+        """Set self[key] to value."""
+        ...
     @overload
-    def __setitem__(self, key: slice, value: array[_T], /) -> None: ...
-    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
-    def __add__(self, value: array[_T], /) -> array[_T]: ...
-    def __eq__(self, value: object, /) -> bool: ...
-    def __ge__(self, value: array[_T], /) -> bool: ...
-    def __gt__(self, value: array[_T], /) -> bool: ...
-    def __iadd__(self, value: array[_T], /) -> Self: ...  # type: ignore[override]
-    def __imul__(self, value: int, /) -> Self: ...
-    def __le__(self, value: array[_T], /) -> bool: ...
-    def __lt__(self, value: array[_T], /) -> bool: ...
-    def __mul__(self, value: int, /) -> array[_T]: ...
-    def __rmul__(self, value: int, /) -> array[_T]: ...
-    def __copy__(self) -> array[_T]: ...
-    def __deepcopy__(self, unused: Any, /) -> array[_T]: ...
-    def __buffer__(self, flags: int, /) -> memoryview: ...
-    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+    def __setitem__(self, key: slice, value: array[_T], /) -> None:
+        """Set self[key] to value."""
+        ...
+    def __delitem__(self, key: SupportsIndex | slice, /) -> None:
+        """Delete self[key]."""
+        ...
+    def __add__(self, value: array[_T], /) -> array[_T]:
+        """Return self+value."""
+        ...
+    def __eq__(self, value: object, /) -> bool:
+        """Return self==value."""
+        ...
+    def __ge__(self, value: array[_T], /) -> bool:
+        """Return self>=value."""
+        ...
+    def __gt__(self, value: array[_T], /) -> bool:
+        """Return self>value."""
+        ...
+    def __iadd__(self, value: array[_T], /) -> Self:
+        """Implement self+=value."""
+        ...
+    def __imul__(self, value: int, /) -> Self:
+        """Implement self*=value."""
+        ...
+    def __le__(self, value: array[_T], /) -> bool:
+        """Return self<=value."""
+        ...
+    def __lt__(self, value: array[_T], /) -> bool:
+        """Return self<value."""
+        ...
+    def __mul__(self, value: int, /) -> array[_T]:
+        """Return self*value."""
+        ...
+    def __rmul__(self, value: int, /) -> array[_T]:
+        """Return value*self."""
+        ...
+    def __copy__(self) -> array[_T]:
+        """Return a copy of the array."""
+        ...
+    def __deepcopy__(self, unused: Any, /) -> array[_T]:
+        """Return a copy of the array."""
+        ...
+    def __buffer__(self, flags: int, /) -> memoryview:
+        """Return a buffer object that exposes the underlying memory of the object."""
+        ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None:
+        """Release the buffer object that exposes the underlying memory of the object."""
+        ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 ArrayType = array

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

@@ -1,3 +1,9 @@
+"""
+allow programmer to define multiple exit functions to be executedupon normal program termination.
+
+Two public functions, register and unregister, are defined.
+"""
+
 from collections.abc import Callable
 from typing import TypeVar
 from typing_extensions import ParamSpec
@@ -5,8 +11,47 @@ from typing_extensions import ParamSpec
 _T = TypeVar("_T")
 _P = ParamSpec("_P")
 
-def _clear() -> None: ...
-def _ncallbacks() -> int: ...
-def _run_exitfuncs() -> None: ...
-def register(func: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
-def unregister(func: Callable[..., object], /) -> None: ...
+def _clear() -> None:
+    """
+    _clear() -> None
+
+    Clear the list of previously registered exit functions.
+    """
+    ...
+def _ncallbacks() -> int:
+    """
+    _ncallbacks() -> int
+
+    Return the number of registered exit functions.
+    """
+    ...
+def _run_exitfuncs() -> None:
+    """
+    _run_exitfuncs() -> None
+
+    Run all registered exit functions.
+    """
+    ...
+def register(func: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]:
+    """
+    register(func, *args, **kwargs) -> func
+
+    Register a function to be executed upon normal program termination
+
+        func - function to be called at exit
+        args - optional arguments to pass to func
+        kwargs - optional keyword arguments to pass to func
+
+        func is returned to facilitate usage as a decorator.
+    """
+    ...
+def unregister(func: Callable[..., object], /) -> None:
+    """
+    unregister(func) -> None
+
+    Unregister an exit function which was previously registered using
+    atexit.register
+
+        func - function to be unregistered
+    """
+    ...

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

@@ -5,26 +5,66 @@ _RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
 
 class error(Exception): ...
 
-def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes: ...
-def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
-def alaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
-def avg(fragment: Buffer, width: int, /) -> int: ...
-def avgpp(fragment: Buffer, width: int, /) -> int: ...
-def bias(fragment: Buffer, width: int, bias: int, /) -> bytes: ...
-def byteswap(fragment: Buffer, width: int, /) -> bytes: ...
-def cross(fragment: Buffer, width: int, /) -> int: ...
-def findfactor(fragment: Buffer, reference: Buffer, /) -> float: ...
-def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]: ...
-def findmax(fragment: Buffer, length: int, /) -> int: ...
-def getsample(fragment: Buffer, width: int, index: int, /) -> int: ...
-def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
-def lin2alaw(fragment: Buffer, width: int, /) -> bytes: ...
-def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes: ...
-def lin2ulaw(fragment: Buffer, width: int, /) -> bytes: ...
-def max(fragment: Buffer, width: int, /) -> int: ...
-def maxpp(fragment: Buffer, width: int, /) -> int: ...
-def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]: ...
-def mul(fragment: Buffer, width: int, factor: float, /) -> bytes: ...
+def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes:
+    """Return a fragment which is the addition of the two samples passed as parameters."""
+    ...
+def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
+    """Decode an Intel/DVI ADPCM coded fragment to a linear fragment."""
+    ...
+def alaw2lin(fragment: Buffer, width: int, /) -> bytes:
+    """Convert sound fragments in a-LAW encoding to linearly encoded sound fragments."""
+    ...
+def avg(fragment: Buffer, width: int, /) -> int:
+    """Return the average over all samples in the fragment."""
+    ...
+def avgpp(fragment: Buffer, width: int, /) -> int:
+    """Return the average peak-peak value over all samples in the fragment."""
+    ...
+def bias(fragment: Buffer, width: int, bias: int, /) -> bytes:
+    """Return a fragment that is the original fragment with a bias added to each sample."""
+    ...
+def byteswap(fragment: Buffer, width: int, /) -> bytes:
+    """Convert big-endian samples to little-endian and vice versa."""
+    ...
+def cross(fragment: Buffer, width: int, /) -> int:
+    """Return the number of zero crossings in the fragment passed as an argument."""
+    ...
+def findfactor(fragment: Buffer, reference: Buffer, /) -> float:
+    """Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal."""
+    ...
+def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]:
+    """Try to match reference as well as possible to a portion of fragment."""
+    ...
+def findmax(fragment: Buffer, length: int, /) -> int:
+    """Search fragment for a slice of specified number of samples with maximum energy."""
+    ...
+def getsample(fragment: Buffer, width: int, index: int, /) -> int:
+    """Return the value of sample index from the fragment."""
+    ...
+def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
+    """Convert samples to 4 bit Intel/DVI ADPCM encoding."""
+    ...
+def lin2alaw(fragment: Buffer, width: int, /) -> bytes:
+    """Convert samples in the audio fragment to a-LAW encoding."""
+    ...
+def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes:
+    """Convert samples between 1-, 2-, 3- and 4-byte formats."""
+    ...
+def lin2ulaw(fragment: Buffer, width: int, /) -> bytes:
+    """Convert samples in the audio fragment to u-LAW encoding."""
+    ...
+def max(fragment: Buffer, width: int, /) -> int:
+    """Return the maximum of the absolute value of all samples in a fragment."""
+    ...
+def maxpp(fragment: Buffer, width: int, /) -> int:
+    """Return the maximum peak-peak value in the sound fragment."""
+    ...
+def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]:
+    """Return the minimum and maximum values of all samples in the sound fragment."""
+    ...
+def mul(fragment: Buffer, width: int, factor: float, /) -> bytes:
+    """Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor."""
+    ...
 def ratecv(
     fragment: Buffer,
     width: int,
@@ -35,9 +75,21 @@ def ratecv(
     weightA: int = 1,
     weightB: int = 0,
     /,
-) -> tuple[bytes, _RatecvState]: ...
-def reverse(fragment: Buffer, width: int, /) -> bytes: ...
-def rms(fragment: Buffer, width: int, /) -> int: ...
-def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
-def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
-def ulaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
+) -> tuple[bytes, _RatecvState]:
+    """Convert the frame rate of the input fragment."""
+    ...
+def reverse(fragment: Buffer, width: int, /) -> bytes:
+    """Reverse the samples in a fragment and returns the modified fragment."""
+    ...
+def rms(fragment: Buffer, width: int, /) -> int:
+    """Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n)."""
+    ...
+def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
+    """Convert a stereo fragment to a mono fragment."""
+    ...
+def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
+    """Generate a stereo fragment from a mono fragment."""
+    ...
+def ulaw2lin(fragment: Buffer, width: int, /) -> bytes:
+    """Convert sound fragments in u-LAW encoding to linearly encoded sound fragments."""
+    ...

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

@@ -1,3 +1,5 @@
+"""Conversion between binary data and ASCII"""
+
 import sys
 from _typeshed import ReadableBuffer
 from typing_extensions import TypeAlias
@@ -6,31 +8,116 @@ from typing_extensions import TypeAlias
 # or ASCII-only strings.
 _AsciiBuffer: TypeAlias = str | ReadableBuffer
 
-def a2b_uu(data: _AsciiBuffer, /) -> bytes: ...
-def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes: ...
+def a2b_uu(data: _AsciiBuffer, /) -> bytes:
+    """Decode a line of uuencoded data."""
+    ...
+def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes:
+    """Uuencode line of data."""
+    ...
 
 if sys.version_info >= (3, 11):
-    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes: ...
+    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes:
+        """
+        Decode a line of base64 data.
+
+        strict_mode
+          When set to True, bytes that are not part of the base64 standard are not allowed.
+          The same applies to excess data after padding (= / ==).
+        """
+        ...
 
 else:
-    def a2b_base64(data: _AsciiBuffer, /) -> bytes: ...
+    def a2b_base64(data: _AsciiBuffer, /) -> bytes:
+        """Decode a line of base64 data."""
+        ...
+
+def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes:
+    """Base64-code line of data."""
+    ...
+def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes:
+    """Decode a string of qp-encoded data."""
+    ...
+def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes:
+    r"""
+    Encode a string using quoted-printable encoding.
 
-def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes: ...
-def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes: ...
-def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes: ...
+    On encoding, when istext is set, newlines are not encoded, and white
+    space at end of lines is.  When istext is not set, \r and \n (CR/LF)
+    are both encoded.  When quotetabs is set, space and tabs are encoded.
+    """
+    ...
 
 if sys.version_info < (3, 11):
-    def a2b_hqx(data: _AsciiBuffer, /) -> bytes: ...
-    def rledecode_hqx(data: ReadableBuffer, /) -> bytes: ...
-    def rlecode_hqx(data: ReadableBuffer, /) -> bytes: ...
-    def b2a_hqx(data: ReadableBuffer, /) -> bytes: ...
-
-def crc_hqx(data: ReadableBuffer, crc: int, /) -> int: ...
-def crc32(data: ReadableBuffer, crc: int = 0, /) -> int: ...
-def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
-def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
-def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes: ...
-def unhexlify(hexstr: _AsciiBuffer, /) -> bytes: ...
+    def a2b_hqx(data: _AsciiBuffer, /) -> bytes:
+        """Decode .hqx coding."""
+        ...
+    def rledecode_hqx(data: ReadableBuffer, /) -> bytes:
+        """Decode hexbin RLE-coded string."""
+        ...
+    def rlecode_hqx(data: ReadableBuffer, /) -> bytes:
+        """Binhex RLE-code binary data."""
+        ...
+    def b2a_hqx(data: ReadableBuffer, /) -> bytes:
+        """Encode .hqx data."""
+        ...
+
+def crc_hqx(data: ReadableBuffer, crc: int, /) -> int:
+    """Compute CRC-CCITT incrementally."""
+    ...
+def crc32(data: ReadableBuffer, crc: int = 0, /) -> int:
+    """Compute CRC-32 incrementally."""
+    ...
+def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes:
+    r"""
+    Hexadecimal representation of binary data.
+
+      sep
+        An optional single character or byte to separate hex bytes.
+      bytes_per_sep
+        How many bytes between separators.  Positive values count from the
+        right, negative values count from the left.
+
+    The return value is a bytes object.  This function is also
+    available as "hexlify()".
+
+    Example:
+    >>> binascii.b2a_hex(b'\xb9\x01\xef')
+    b'b901ef'
+    >>> binascii.hexlify(b'\xb9\x01\xef', ':')
+    b'b9:01:ef'
+    >>> binascii.b2a_hex(b'\xb9\x01\xef', b'_', 2)
+    b'b9_01ef'
+    """
+    ...
+def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes:
+    """
+    Hexadecimal representation of binary data.
+
+      sep
+        An optional single character or byte to separate hex bytes.
+      bytes_per_sep
+        How many bytes between separators.  Positive values count from the
+        right, negative values count from the left.
+
+    The return value is a bytes object.  This function is also
+    available as "b2a_hex()".
+    """
+    ...
+def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes:
+    """
+    Binary data of hexadecimal representation.
+
+    hexstr must contain an even number of hex digits (upper or lower case).
+    This function is also available as "unhexlify()".
+    """
+    ...
+def unhexlify(hexstr: _AsciiBuffer, /) -> bytes:
+    """
+    Binary data of hexadecimal representation.
+
+    hexstr must contain an even number of hex digits (upper or lower case).
+    """
+    ...
 
 class Error(ValueError): ...
 class Incomplete(Exception): ...