chromatic-python 0.2.2__tar.gz → 0.3.1__tar.gz

{chromatic_python-0.2.2 → chromatic_python-0.3.1}/.gitignore

@@ -5,7 +5,7 @@ __pycache__/
 /dist/
 /docs/
 /tests/_*
-/chromatic/data/*.json
-/chromatic/data/*.pyi
+/chromatic/data/userfont.json
 /chromatic/_version.py
 /*.egg-info/
+/build/

{chromatic_python-0.2.2/chromatic_python.egg-info → chromatic_python-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chromatic-python
-Version: 0.2.2
+Version: 0.3.1
 Summary: ANSI art image processing and colored terminal text
 Author: crypt0lith
 License: MIT License
@@ -27,7 +27,6 @@ License: MIT License
 Project-URL: Homepage, https://github.com/crypt0lith/chromatic
 Keywords: ansi,ascii,art,font,image,terminal,parser
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
@@ -42,6 +41,7 @@ Requires-Dist: scikit-image~=0.25.2
 Requires-Dist: scikit-learn~=1.6.1
 Requires-Dist: fonttools~=4.58.0
 Requires-Dist: scipy~=1.15.3
+Requires-Dist: lazy_loader~=0.4
 Dynamic: license-file
 
 ![image](/logo/logo.PNG)

chromatic_python-0.3.1/chromatic/__init__.py

@@ -0,0 +1,8 @@
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "0.0.0"
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

chromatic_python-0.3.1/chromatic/__init__.pyi

@@ -0,0 +1,74 @@
+__all__ = [
+    'AnsiImage',
+    'Back',
+    'Color',
+    'ColorNamespace',
+    'ColorStr',
+    'Fore',
+    'SgrParameter',
+    'Style',
+    '__version__',
+    'ansi2img',
+    'ansi_quantize',
+    'ansicolor24Bit',
+    'ansicolor4Bit',
+    'ansicolor8Bit',
+    'ansify',
+    'image',
+    'ascii2img',
+    'ascii_printable',
+    'color',
+    'colorbytes',
+    'contrast_stretch',
+    'cp437_printable',
+    'data',
+    'equalize_white_point',
+    'get_font_key',
+    'get_font_object',
+    'get_glyph_masks',
+    'img2ansi',
+    'img2ascii',
+    'named_color',
+    'read_ans',
+    'register_userfont',
+    'render_ans',
+    'reshape_ansi',
+    'to_sgr_array',
+]
+from . import color, data, image
+from ._version import version as __version__
+from .color import (
+    Back,
+    Color,
+    ColorNamespace,
+    ColorStr,
+    Fore,
+    SgrParameter,
+    Style,
+    ansicolor24Bit,
+    ansicolor4Bit,
+    ansicolor8Bit,
+    colorbytes,
+    named_color,
+)
+from .data import register_userfont
+from .image import (
+    AnsiImage,
+    ansi2img,
+    ansi_quantize,
+    ansify,
+    ascii2img,
+    ascii_printable,
+    contrast_stretch,
+    cp437_printable,
+    equalize_white_point,
+    get_font_key,
+    get_font_object,
+    img2ansi,
+    img2ascii,
+    read_ans,
+    render_ans,
+    reshape_ansi,
+    to_sgr_array,
+)
+from .image._glyph_proc import get_glyph_masks

{chromatic_python-0.2.2 → chromatic_python-0.3.1}/chromatic/_typing.py

@@ -14,12 +14,13 @@ from typing import (
     Concatenate,
     Hashable,
     Iterable,
-    Literal,
+    Literal as L,
     NamedTuple,
     Optional,
     ParamSpec,
     Protocol,
     Sequence,
+    TYPE_CHECKING,
     Type,
     TypeAlias,
     TypeAliasType,
@@ -40,7 +41,8 @@ from PIL.ImageFont import FreeTypeFont
 from numpy import dtype, float64, generic, ndarray, number, uint8
 from numpy._typing import NDArray, _ArrayLike
 
-from chromatic.data import UserFont
+if TYPE_CHECKING:
+    from .data import UserFont
 
 _P = ParamSpec('_P')
 _T = TypeVar('_T')
@@ -48,11 +50,15 @@ _T_co = TypeVar('_T_co', covariant=True)
 _T_contra = TypeVar('_T_contra', contravariant=True)
 _AnyNumber_co = TypeVar('_AnyNumber_co', number, Number, covariant=True)
 
-type ArrayReducerFunc[_SCT: generic] = Callable[Concatenate[_ArrayLike[_SCT], _P], NDArray[_SCT]]
-type ShapedNDArray[_Shape: tuple[int, ...], _SCT: generic] = ndarray[_Shape, dtype[_SCT]]
+type ArrayReducerFunc[_SCT: generic] = Callable[
+    Concatenate[_ArrayLike[_SCT], _P], NDArray[_SCT]
+]
+type ShapedNDArray[_Shape: tuple[int, ...], _SCT = generic] = ndarray[
+    _Shape, dtype[_SCT]
+]
 type MatrixLike[_SCT: generic] = ShapedNDArray[TupleOf2[int], _SCT]
 type SquareMatrix[_I: int, _SCT: generic] = ShapedNDArray[TupleOf2[_I], _SCT]
-type GlyphArray[_SCT: generic] = SquareMatrix[Literal[24], _SCT]
+type GlyphArray[_SCT: generic] = SquareMatrix[L[24], _SCT]
 type TupleOf2[_T] = tuple[_T, _T]
 type TupleOf3[_T] = tuple[_T, _T, _T]
 
@@ -64,25 +70,45 @@ GlyphBitmask: TypeAlias = GlyphArray[bool]
 Bitmask: TypeAlias = MatrixLike[bool]
 GreyscaleGlyphArray: TypeAlias = GlyphArray[float64]
 GreyscaleArray: TypeAlias = MatrixLike[float64]
-RGBArray: TypeAlias = ShapedNDArray[tuple[int, int, Literal[3]], uint8]
-RGBPixel: TypeAlias = ShapedNDArray[tuple[Literal[3]], uint8]
+RGBArray: TypeAlias = ShapedNDArray[tuple[int, int, L[3]], uint8]
+RGBPixel: TypeAlias = ShapedNDArray[tuple[L[3]], uint8]
 
 RGBImageLike: TypeAlias = Image | RGBArray
-RGBVectorLike: TypeAlias = Int3Tuple | IntSequence | RGBPixel
-ColorDictKeys = Literal['fg', 'bg']
-Ansi4BitAlias = Literal['4b']
-Ansi8BitAlias = Literal['8b']
-Ansi24BitAlias = Literal['24b']
+RGBVectorLike: TypeAlias = IntSequence | RGBPixel
+ColorDictKeys = L['fg', 'bg']
+Ansi4BitAlias = L['4b']
+Ansi8BitAlias = L['8b']
+Ansi24BitAlias = L['24b']
 AnsiColorAlias = Ansi4BitAlias | Ansi8BitAlias | Ansi24BitAlias
-FontArgType: TypeAlias = FreeTypeFont | UserFont | str | int
+FontArgType: TypeAlias = 'FreeTypeFont | UserFont | str'
+
+
+def eval_annotation(annotation: str, **kwargs) -> Any:
+    globals_ = kwargs.get('globals', {}) | globals()
+    locals_ = kwargs.get('locals', {})
+    try:
+        return subtype(eval(annotation, globals_.copy(), locals_.copy()))
+    except NameError as e:
+        try:
+            import typing
+
+            globals_[e.name] = getattr(typing, e.name)
+            return eval_annotation(annotation, globals=globals_, locals=locals_)
+        except AttributeError:
+            pass
+        raise
 
 
 def type_error_msg(err_obj, *expected, context: str = '', obj_repr=False):
     n_expected = len(expected)
-    name_slots = ['{%d.__qualname__!r}' % n for n in range(n_expected)]
-    if name_slots and n_expected > 1:
+    name_slots = ["{%d.__name__!r}" % n for n in range(n_expected)]
+    if n_expected > 1:
         name_slots[-1] = f"or {name_slots[-1]}"
-    names = (', ' if n_expected > 2 else ' ').join([context.strip()] + name_slots).format(*expected)
+    names = (
+        (', ' if n_expected > 2 else ' ')
+        .join([context.strip(), *name_slots])
+        .format(*expected)
+    )
     if not obj_repr:
         if not isinstance(err_obj, type):
             err_obj = type(err_obj)
@@ -100,11 +126,14 @@ def is_matching_type(value, typ):
     origin, args = deconstruct_type(typ)
     if origin is Union:
         return any(is_matching_type(value, arg) for arg in args)
-    elif origin is Literal:
+    elif origin is L:
         return value in args
     elif isinstance(typ, TypeVar):
         if typ.__constraints__:
-            return any(is_matching_type(value, constraint) for constraint in typ.__constraints__)
+            return any(
+                is_matching_type(value, constraint)
+                for constraint in typ.__constraints__
+            )
         else:
             return True
     elif origin is type:
@@ -162,7 +191,9 @@ def is_matching_typed_dict(__d: dict, typed_dict: type[dict]) -> tuple[bool, str
         field = __d.get(name)
         if field is None or is_matching_type(field, typ):
             continue
-        return False, type_error_msg(field, typ, context=f'keyword argument {name!r} of type')
+        return False, type_error_msg(
+            field, typ, context=f'keyword argument {name!r} of type'
+        )
     return True, ''
 
 
@@ -188,20 +219,20 @@ def unionize(__iterable: Iterable[SupportsUnion[_T_contra, _T_co]]) -> _T_co:
 
 _GenericAlias = type(Type[...]) | types.GenericAlias
 _UnionGenericType = type(Union[..., None])
-_LiteralGenericType = type(Literal[''])
+_LiteralGenericType = type(L[''])
 _CallableGenericType = type(Callable[[], ...]) | type(ABC_Callable[[], ...])
 _CallableType = type(Callable) | ABC_Callable
 
 
 class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
+    """Bounded OrderedDict, mimics FIFO behavior of `functools.lru_cache`"""
 
     def __init__(self, *, maxsize: Optional[int] = 128):
-        """Bounded OrderedDict, mimics FIFO behavior of `functools.lru_cache`"""
         super().__init__()
         if maxsize is not None:
             maxsize = max(maxsize, 0)
 
-            @wraps(self.__setitem__)
+            @wraps(_BoundedDict.__setitem__)
             def _fifo(_, key, value):
                 if maxsize <= len(self):
                     self.popitem(last=True)
@@ -213,9 +244,9 @@ class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
 
 
 _SUBTYPE_CACHE: _BoundedDict[int, ...] = _BoundedDict()
-_ATTR_GETTERS: _BoundedDict[..., tuple[Callable[[Iterable], NamedTuple], op.attrgetter]] = (
-    _BoundedDict()
-)
+_ATTR_GETTERS: _BoundedDict[
+    ..., tuple[Callable[[Iterable], NamedTuple], op.attrgetter]
+] = _BoundedDict()
 
 
 def _unique_attrs(obj) -> Optional['NamedTuple']:
@@ -260,7 +291,8 @@ def _sort_attrs(obj, tp_name, attr_names):
     try:
         sig = inspect.signature(type(obj))
         indices = (
-            dict.fromkeys(field_names, inf) | {p: i for i, p in enumerate(sig.parameters)}
+            dict.fromkeys(field_names, inf)
+            | {p: i for i, p in enumerate(sig.parameters)}
         ).values()
         for names in (attr_names, field_names):
             names.sort(key=dict(zip(names, indices)).__getitem__)
@@ -282,7 +314,9 @@ def _sort_attrs(obj, tp_name, attr_names):
                     while sig_start not in line:
                         line = next(lines)
                     _, _, params = line.partition(sig_start)
-                    params, _, _ = (s.translate(no_square_parens) for s in params.partition(')'))
+                    params, _, _ = (
+                        s.translate(no_square_parens) for s in params.partition(')')
+                    )
                     maybe_sigs.add(params)
                 except StopIteration:
                     break
@@ -290,15 +324,20 @@ def _sort_attrs(obj, tp_name, attr_names):
     if maybe_sigs:
         if len(maybe_sigs) > 1:
             sig = max(
-                maybe_sigs, key=lambda s: sum(1 for sub in s.split(', ') if sub in field_names)
+                maybe_sigs,
+                key=lambda s: sum(1 for sub in s.split(', ') if sub in field_names),
             )
         else:
             sig = maybe_sigs.pop()
         positions = {x: i for i, x in enumerate(sig.split(', ')) if x}
         sorted_field_names = sorted(field_names, key=lambda k: positions.get(k, inf))
-        transitions = {idx: sorted_field_names.index(x) for idx, x in enumerate(field_names)}
+        transitions = {
+            idx: sorted_field_names.index(x) for idx, x in enumerate(field_names)
+        }
         field_names = sorted_field_names
-        attr_names = [attr_names[k] for k in map(transitions.__getitem__, range(len(attr_names)))]
+        attr_names = [
+            attr_names[k] for k in map(transitions.__getitem__, range(len(attr_names)))
+        ]
     for Names in (attr_names, field_names):
         name_attr = next((s for s in Names if s.strip('_') == 'name'), None)
         if name_attr is not None:
@@ -335,7 +374,9 @@ def subtype[_T](typ: _T) -> _T:
             args_list = list(args)
             if (
                 literals := [
-                    idx for idx, elem in enumerate(args) if isinstance(elem, _LiteralGenericType)
+                    idx
+                    for idx, elem in enumerate(args)
+                    if isinstance(elem, _LiteralGenericType)
                 ]
             ) and len(literals) > 1:
 
@@ -345,7 +386,7 @@ def subtype[_T](typ: _T) -> _T:
                     return getattr(value, '__args__', ())
 
                 start = args[literals.pop(0)]
-                args_list[args_list.index(start)] = Literal[
+                args_list[args_list.index(start)] = L[
                     *start.__args__,
                     *dict.fromkeys(arg for idx in literals for arg in _next_args(idx)),
                 ]

{chromatic_python-0.2.2 → chromatic_python-0.3.1}/chromatic/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)

chromatic_python-0.3.1/chromatic/color/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

chromatic_python-0.3.1/chromatic/color/__init__.pyi

@@ -0,0 +1,86 @@
+__all__ = [
+    'ANSI_4BIT_RGB',
+    'Back',
+    'CSI',
+    'Color',
+    'ColorNamespace',
+    'ColorStr',
+    'Fore',
+    'SGR_RESET',
+    'SgrParameter',
+    'SgrSequence',
+    'Style',
+    'ansi_4bit_to_rgb',
+    'ansi_8bit_to_rgb',
+    'ansicolor24Bit',
+    'ansicolor4Bit',
+    'ansicolor8Bit',
+    'color_chain',
+    'colorbytes',
+    'get_ansi_type',
+    'int2rgb',
+    'hexstr2rgb',
+    'hsl2rgb',
+    'hsv2rgb',
+    'is_u24',
+    'lab2rgb',
+    'lab2xyz',
+    'named_color',
+    'nearest_ansi_4bit_rgb',
+    'nearest_ansi_8bit_rgb',
+    'randcolor',
+    'rgb2ansi_escape',
+    'rgb2int',
+    'rgb2hexstr',
+    'rgb2hsl',
+    'rgb2hsv',
+    'rgb2lab',
+    'rgb2xyz',
+    'rgb_diff',
+    'rgb_dispatch',
+    'rgb_to_ansi_8bit',
+    'xyz2lab',
+    'xyz2rgb',
+]
+from . import colorconv, core, iterators, palette
+from .colorconv import (
+    ANSI_4BIT_RGB,
+    ansi_4bit_to_rgb,
+    ansi_8bit_to_rgb,
+    int2rgb,
+    hexstr2rgb,
+    hsl2rgb,
+    hsv2rgb,
+    is_u24,
+    lab2rgb,
+    lab2xyz,
+    nearest_ansi_4bit_rgb,
+    nearest_ansi_8bit_rgb,
+    rgb2int,
+    rgb2hexstr,
+    rgb2hsl,
+    rgb2hsv,
+    rgb2lab,
+    rgb2xyz,
+    rgb_diff,
+    rgb_to_ansi_8bit,
+    xyz2lab,
+    xyz2rgb,
+)
+from .core import (
+    CSI,
+    Color,
+    ColorStr,
+    SGR_RESET,
+    SgrParameter,
+    SgrSequence,
+    ansicolor24Bit,
+    ansicolor4Bit,
+    ansicolor8Bit,
+    color_chain,
+    colorbytes,
+    get_ansi_type,
+    randcolor,
+    rgb2ansi_escape,
+)
+from .palette import Back, ColorNamespace, Fore, Style, named_color, rgb_dispatch

{chromatic_python-0.2.2 → chromatic_python-0.3.1}/chromatic/color/colorconv.py

@@ -2,16 +2,16 @@ __all__ = [
     'ANSI_4BIT_RGB',
     'ansi_4bit_to_rgb',
     'ansi_8bit_to_rgb',
-    'hex2rgb',
+    'int2rgb',
     'hexstr2rgb',
     'hsl2rgb',
     'hsv2rgb',
-    'is_hex_rgb',
+    'is_u24',
     'lab2rgb',
     'lab2xyz',
     'nearest_ansi_4bit_rgb',
     'nearest_ansi_8bit_rgb',
-    'rgb2hex',
+    'rgb2int',
     'rgb2hexstr',
     'rgb2hsl',
     'rgb2hsv',
@@ -23,40 +23,76 @@ __all__ = [
     'xyz2rgb',
 ]
 
+from functools import lru_cache
 from operator import mul, truediv
-from typing import Final, Literal, SupportsInt, cast
+from typing import Final, Literal, SupportsInt, TypeGuard
 
 import numpy as np
 
-from .._typing import Float3Tuple, FloatSequence, Int3Tuple, RGBPixel, RGBVectorLike, ShapedNDArray
-
-
-def is_hex_rgb(value, *, strict: bool = False):
-    if issubclass(type(value), SupportsInt):
-        if 0x0 <= int(value) <= 0xFFFFFF:
+from .._typing import (
+    Float3Tuple,
+    FloatSequence,
+    Int3Tuple,
+    RGBPixel,
+    RGBVectorLike,
+    ShapedNDArray,
+)
+
+
+@lru_cache
+def _supports_int(typ: type) -> TypeGuard[type[SupportsInt]]:
+    return issubclass(typ, SupportsInt)
+
+
+def is_u24(value, *, strict: bool = False):
+    """Check if value is an unsigned 24-bit integer.
+
+    Parameters
+    ---------
+    value
+        Input number
+    strict : bool
+        Whether to return False or raise ValueError on failure
+
+    Raises
+    ------
+    ValueError
+        Raised when `strict=True` and value is not u24
+    """
+    if _supports_int(type(value)):
+        if 0 <= int(value) <= 0xFFFFFF:
             return True
         elif not strict:
             return False
-    raise TypeError(f"{value!r} is not a valid RGB color") from None
+    raise ValueError(f"{value!r} is not u24")
 
 
 def hexstr2rgb(__str: str) -> Int3Tuple:
-    if is_hex_rgb(value := int(__str, 16), strict=True):
-        return hex2rgb(value)
+    n = len(__str)
+    if n % 4 == 0:  # trunc alpha
+        n *= 3
+        n //= 4
+        __str = __str[:n]
+    if n == 3:  # rgb -> rrggbb
+        __str = ''.join(c * 2 for c in __str)
+    if is_u24(value := int(__str, 16), strict=True):
+        return int2rgb(value)
 
 
 def rgb2hexstr(rgb: RGBVectorLike) -> str:
-    r, g, b = rgb
-    return f'{r:02x}{g:02x}{b:02x}'
+    return "%02x%02x%02x" % tuple(rgb)
 
 
-def rgb2hex(rgb: RGBVectorLike) -> int:
+def rgb2int(rgb: RGBVectorLike) -> int:
     r, g, b = map(int, rgb)
     return r << 16 | g << 8 | b
 
 
-def hex2rgb(value: int) -> Int3Tuple:
-    return (value >> 16) & 0xFF, (value >> 8) & 0xFF, value & 0xFF
+def int2rgb(__x: int) -> Int3Tuple:
+    try:
+        return getattr(__x, 'rgb')
+    except AttributeError:
+        return (__x >> 16) & 0xFF, (__x >> 8) & 0xFF, __x & 0xFF
 
 
 def xyz2lab(xyz: FloatSequence) -> Float3Tuple:
@@ -78,7 +114,10 @@ def lab2xyz(lab: FloatSequence) -> Float3Tuple:
     x, y, z = map(
         mul,
         (95.047, 100.0, 108.883),
-        map(lambda n: (lambda c: c if c > 0.008856 else (n - 16 / 116) / 7.787)(n**3), (x, y, z)),
+        map(
+            lambda i: (lambda j: j if j > 0.008856 else (i - 16 / 116) / 7.787)(i**3),
+            (x, y, z),
+        ),
     )
     return x, y, z
 
@@ -98,47 +137,44 @@ def rgb2xyz(rgb: RGBPixel) -> Float3Tuple:
 
 
 def xyz2rgb(xyz: ShapedNDArray[tuple[Literal[3]], np.float64]) -> Int3Tuple:
-    r, g, b = (np.clip(M_XYZ2RGB @ np.array(xyz, dtype=np.float64), 0.0, 1.0) * 255.0).astype(int)
+    r, g, b = (
+        np.clip(M_XYZ2RGB @ np.array(xyz, dtype=np.float64), 0.0, 1.0) * 255.0
+    ).astype(int)
     return r, g, b
 
 
 def hsl2rgb(hsl: FloatSequence) -> Int3Tuple:
     h, s, L = hsl
-    h = (h / 360) % 1
+    h /= 360
+    h %= 1
     if h < 0:
         h += 1
-    r = g = b = L
     v = (L * (1.0 + s)) if L <= 0.5 else (L + s - L * s)
-    if v > 0:
+    if v > 0 and 0 <= (sextant := int(h)) <= 5:
         m = L + L - v
         sv = (v - m) / v
         h *= 6.0
-        sextant = int(h)
-        fract = h - sextant
-        vsf = v * sv * fract
+        vsf = v * sv * (h - sextant)
         mid1 = m + vsf
         mid2 = v - vsf
-        if sextant == 0:
-            r, g, b = v, mid1, m
-        elif sextant == 1:
-            r, g, b = mid2, v, m
-        elif sextant == 2:
-            r, g, b = m, v, mid1
-        elif sextant == 3:
-            r, g, b = m, mid2, v
-        elif sextant == 4:
-            r, g, b = mid1, m, v
-        elif sextant == 5:
-            r, g, b = v, m, mid2
-        r, g, b = (round(x * 255) for x in (r, g, b))
+        r, g, b = (
+            round(x * 0xFF)
+            for x in [
+                [v, mid1, m],
+                [mid2, v, m],
+                [m, v, mid1],
+                [m, mid2, v],
+                [mid1, m, v],
+            ][sextant]
+        )
     else:
-        r, g, b = (round(L * 255) for _ in range(3))
+        r, g, b = [round(L * 0xFF)] * 3
     return r, g, b
 
 
 def rgb2hsl(rgb: RGBVectorLike) -> Float3Tuple:
     r, g, b = (x / 255.0 for x in rgb)
-    m, v = sorted([r, g, b])[::2]
+    m, _, v = sorted([r, g, b])
     L = (m + v) / 2
     h = s = 0
     if L > 0:
@@ -245,7 +281,7 @@ def ansi_4bit_to_rgb(value: int):
     return ANSI_4BIT_RGB[value]
 
 
-def _4b_lookup():
+def _4b_lookup() -> dict[Int3Tuple, Int3Tuple]:
     def rgb_dist(rgb, ansi):
         r_mean = (rgb[:, 0:1] + ansi[:, 0]) / 2
         r_diff = (rgb[:, 0:1] - ansi[:, 0]) * (2 + r_mean / 256)
@@ -255,14 +291,15 @@ def _4b_lookup():
 
     rgb_4b_arr = np.asarray(ANSI_4BIT_RGB)
     quants = np.stack(
-        np.meshgrid(*np.repeat(np.arange(32).reshape([1, -1]), 3, 0), indexing='ij'), axis=-1
+        np.meshgrid(*np.repeat(np.arange(32).reshape([1, -1]), 3, 0), indexing='ij'),
+        axis=-1,
     ).reshape([-1, 3])
-    rgb_colors = quants * 8
-    nearest_colors = rgb_4b_arr[np.argmin(rgb_dist(rgb_colors, rgb_4b_arr), axis=1)]
-    table = {
-        tuple(map(int, color)): tuple(map(int, nearest_colors[i])) for i, color in enumerate(quants)
+    nearest_colors = rgb_4b_arr[np.argmin(rgb_dist(quants * 8, rgb_4b_arr), axis=1)]
+    table: dict = {
+        tuple(map(int, color)): tuple(map(int, nearest_colors[i]))
+        for i, color in enumerate(quants)
     }
-    return cast(dict[Int3Tuple, Int3Tuple], table)
+    return table
 
 
 ANSI_4BIT_RGB_MAP = _4b_lookup()