basedpyright 1.13.2 → 1.13.3

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

@@ -1,90 +1,90 @@
-import sys
-from _typeshed import FileDescriptorLike, ReadableBuffer
-from socket import socket
-from typing import Any, overload
-from typing_extensions import TypeAlias
-
-# cyclic dependence with asynchat
-_MapType: TypeAlias = dict[int, Any]
-_Socket: TypeAlias = socket
-
-socket_map: _MapType  # undocumented
-
-class ExitNow(Exception): ...
-
-def read(obj: Any) -> None: ...
-def write(obj: Any) -> None: ...
-def readwrite(obj: Any, flags: int) -> None: ...
-def poll(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
-def poll2(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
-
-poll3 = poll2
-
-def loop(timeout: float = 30.0, use_poll: bool = False, map: _MapType | None = None, count: int | None = None) -> None: ...
-
-# Not really subclass of socket.socket; it's only delegation.
-# It is not covariant to it.
-class dispatcher:
-    debug: bool
-    connected: bool
-    accepting: bool
-    connecting: bool
-    closing: bool
-    ignore_log_types: frozenset[str]
-    socket: _Socket | None
-    def __init__(self, sock: _Socket | None = None, map: _MapType | None = None) -> None: ...
-    def add_channel(self, map: _MapType | None = None) -> None: ...
-    def del_channel(self, map: _MapType | None = None) -> None: ...
-    def create_socket(self, family: int = ..., type: int = ...) -> None: ...
-    def set_socket(self, sock: _Socket, map: _MapType | None = None) -> None: ...
-    def set_reuse_addr(self) -> None: ...
-    def readable(self) -> bool: ...
-    def writable(self) -> bool: ...
-    def listen(self, num: int) -> None: ...
-    def bind(self, addr: tuple[Any, ...] | str) -> None: ...
-    def connect(self, address: tuple[Any, ...] | str) -> None: ...
-    def accept(self) -> tuple[_Socket, Any] | None: ...
-    def send(self, data: ReadableBuffer) -> int: ...
-    def recv(self, buffer_size: int) -> bytes: ...
-    def close(self) -> None: ...
-    def log(self, message: Any) -> None: ...
-    def log_info(self, message: Any, type: str = "info") -> None: ...
-    def handle_read_event(self) -> None: ...
-    def handle_connect_event(self) -> None: ...
-    def handle_write_event(self) -> None: ...
-    def handle_expt_event(self) -> None: ...
-    def handle_error(self) -> None: ...
-    def handle_expt(self) -> None: ...
-    def handle_read(self) -> None: ...
-    def handle_write(self) -> None: ...
-    def handle_connect(self) -> None: ...
-    def handle_accept(self) -> None: ...
-    def handle_close(self) -> None: ...
-
-class dispatcher_with_send(dispatcher):
-    def initiate_send(self) -> None: ...
-    # incompatible signature:
-    # def send(self, data: bytes) -> int | None: ...
-
-def compact_traceback() -> tuple[tuple[str, str, str], type, type, str]: ...
-def close_all(map: _MapType | None = None, ignore_all: bool = False) -> None: ...
-
-if sys.platform != "win32":
-    class file_wrapper:
-        fd: int
-        def __init__(self, fd: int) -> None: ...
-        def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
-        def send(self, data: bytes, flags: int = ...) -> int: ...
-        @overload
-        def getsockopt(self, level: int, optname: int, buflen: None = None) -> int: ...
-        @overload
-        def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
-        def read(self, bufsize: int, flags: int = ...) -> bytes: ...
-        def write(self, data: bytes, flags: int = ...) -> int: ...
-        def close(self) -> None: ...
-        def fileno(self) -> int: ...
-        def __del__(self) -> None: ...
-
-    class file_dispatcher(dispatcher):
-        def __init__(self, fd: FileDescriptorLike, map: _MapType | None = None) -> None: ...
-        def set_file(self, fd: int) -> None: ...
+import sys
+from _typeshed import FileDescriptorLike, ReadableBuffer
+from socket import socket
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+# cyclic dependence with asynchat
+_MapType: TypeAlias = dict[int, Any]
+_Socket: TypeAlias = socket
+
+socket_map: _MapType  # undocumented
+
+class ExitNow(Exception): ...
+
+def read(obj: Any) -> None: ...
+def write(obj: Any) -> None: ...
+def readwrite(obj: Any, flags: int) -> None: ...
+def poll(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+def poll2(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+
+poll3 = poll2
+
+def loop(timeout: float = 30.0, use_poll: bool = False, map: _MapType | None = None, count: int | None = None) -> None: ...
+
+# Not really subclass of socket.socket; it's only delegation.
+# It is not covariant to it.
+class dispatcher:
+    debug: bool
+    connected: bool
+    accepting: bool
+    connecting: bool
+    closing: bool
+    ignore_log_types: frozenset[str]
+    socket: _Socket | None
+    def __init__(self, sock: _Socket | None = None, map: _MapType | None = None) -> None: ...
+    def add_channel(self, map: _MapType | None = None) -> None: ...
+    def del_channel(self, map: _MapType | None = None) -> None: ...
+    def create_socket(self, family: int = ..., type: int = ...) -> None: ...
+    def set_socket(self, sock: _Socket, map: _MapType | None = None) -> None: ...
+    def set_reuse_addr(self) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def listen(self, num: int) -> None: ...
+    def bind(self, addr: tuple[Any, ...] | str) -> None: ...
+    def connect(self, address: tuple[Any, ...] | str) -> None: ...
+    def accept(self) -> tuple[_Socket, Any] | None: ...
+    def send(self, data: ReadableBuffer) -> int: ...
+    def recv(self, buffer_size: int) -> bytes: ...
+    def close(self) -> None: ...
+    def log(self, message: Any) -> None: ...
+    def log_info(self, message: Any, type: str = "info") -> None: ...
+    def handle_read_event(self) -> None: ...
+    def handle_connect_event(self) -> None: ...
+    def handle_write_event(self) -> None: ...
+    def handle_expt_event(self) -> None: ...
+    def handle_error(self) -> None: ...
+    def handle_expt(self) -> None: ...
+    def handle_read(self) -> None: ...
+    def handle_write(self) -> None: ...
+    def handle_connect(self) -> None: ...
+    def handle_accept(self) -> None: ...
+    def handle_close(self) -> None: ...
+
+class dispatcher_with_send(dispatcher):
+    def initiate_send(self) -> None: ...
+    # incompatible signature:
+    # def send(self, data: bytes) -> int | None: ...
+
+def compact_traceback() -> tuple[tuple[str, str, str], type, type, str]: ...
+def close_all(map: _MapType | None = None, ignore_all: bool = False) -> None: ...
+
+if sys.platform != "win32":
+    class file_wrapper:
+        fd: int
+        def __init__(self, fd: int) -> None: ...
+        def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def send(self, data: bytes, flags: int = ...) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: None = None) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+        def read(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def write(self, data: bytes, flags: int = ...) -> int: ...
+        def close(self) -> None: ...
+        def fileno(self) -> int: ...
+        def __del__(self) -> None: ...
+
+    class file_dispatcher(dispatcher):
+        def __init__(self, fd: FileDescriptorLike, map: _MapType | None = None) -> None: ...
+        def set_file(self, fd: int) -> None: ...

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

@@ -1,95 +1,95 @@
-from typing_extensions import Buffer, TypeAlias
-
-_AdpcmState: TypeAlias = tuple[int, int]
-_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
-
-class error(Exception): ...
-
-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,
-    nchannels: int,
-    inrate: int,
-    outrate: int,
-    state: _RatecvState | None,
-    weightA: int = 1,
-    weightB: int = 0,
-    /,
-) -> 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."""
-    ...
+from typing_extensions import Buffer, TypeAlias
+
+_AdpcmState: TypeAlias = tuple[int, int]
+_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
+
+class error(Exception): ...
+
+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,
+    nchannels: int,
+    inrate: int,
+    outrate: int,
+    state: _RatecvState | None,
+    weightA: int = 1,
+    weightB: int = 0,
+    /,
+) -> 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,123 +1,123 @@
-"""Conversion between binary data and ASCII"""
-
-import sys
-from _typeshed import ReadableBuffer
-from typing_extensions import TypeAlias
-
-# Many functions in binascii accept buffer objects
-# or ASCII-only strings.
-_AsciiBuffer: TypeAlias = str | ReadableBuffer
-
-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:
-        """
-        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:
-        """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.
-
-    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:
-        """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): ...
+"""Conversion between binary data and ASCII"""
+
+import sys
+from _typeshed import ReadableBuffer
+from typing_extensions import TypeAlias
+
+# Many functions in binascii accept buffer objects
+# or ASCII-only strings.
+_AsciiBuffer: TypeAlias = str | ReadableBuffer
+
+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:
+        """
+        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:
+        """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.
+
+    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:
+        """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): ...