chromatic-python 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

chromatic/_typing.py

@@ -50,8 +50,12 @@ _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[L[24], _SCT]
@@ -100,7 +104,11 @@ def type_error_msg(err_obj, *expected, context: str = '', obj_repr=False):
     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)
@@ -122,7 +130,10 @@ def is_matching_type(value, typ):
         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:
@@ -180,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, ''
 
 
@@ -231,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']:
@@ -278,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__)
@@ -300,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
@@ -308,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:
@@ -353,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:
 

chromatic/_version.py

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

chromatic/color/colorconv.py

@@ -29,7 +29,14 @@ from typing import Final, Literal, SupportsInt, TypeGuard
 
 import numpy as np
 
-from .._typing import Float3Tuple, FloatSequence, Int3Tuple, RGBPixel, RGBVectorLike, ShapedNDArray
+from .._typing import (
+    Float3Tuple,
+    FloatSequence,
+    Int3Tuple,
+    RGBPixel,
+    RGBVectorLike,
+    ShapedNDArray,
+)
 
 
 @lru_cache
@@ -107,7 +114,10 @@ def lab2xyz(lab: FloatSequence) -> Float3Tuple:
     x, y, z = map(
         mul,
         (95.047, 100.0, 108.883),
-        map(lambda i: (lambda j: j if j > 0.008856 else (i - 16 / 116) / 7.787)(i**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
 
@@ -127,7 +137,9 @@ 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
 
 
@@ -147,7 +159,13 @@ def hsl2rgb(hsl: FloatSequence) -> Int3Tuple:
         mid2 = v - vsf
         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]
+            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 * 0xFF)] * 3
@@ -273,11 +291,13 @@ def _4b_lookup() -> dict[Int3Tuple, Int3Tuple]:
 
     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])
     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)
+        tuple(map(int, color)): tuple(map(int, nearest_colors[i]))
+        for i, color in enumerate(quants)
     }
     return table
 

chromatic/color/core.py

@@ -149,7 +149,9 @@ _ANSI16C_I2KV = cast(
     dict[int, tuple[ColorDictKeys, Int3Tuple]],
     {
         v: (k, ansi_4bit_to_rgb(v))
-        for x in (zip(('fg', 'bg'), (j, j + 10)) for i in (30, 90) for j in range(i, i + 8))
+        for x in (
+            zip(('fg', 'bg'), (j, j + 10)) for i in (30, 90) for j in range(i, i + 8)
+        )
         for (k, v) in x
     },
 )
@@ -391,7 +393,9 @@ AnsiColorFormat: TypeAlias = ansicolor4Bit | ansicolor8Bit | ansicolor24Bit
 AnsiColorType: TypeAlias = type[AnsiColorFormat]
 AnsiColorParam: TypeAlias = AnsiColorAlias | AnsiColorType
 _AnsiColor_co = TypeVar('_AnsiColor_co', bound=colorbytes, covariant=True)
-_ANSI_COLOR_TYPES = cast(frozenset[AnsiColorType], frozenset(colorbytes.__subclasses__()))
+_ANSI_COLOR_TYPES = cast(
+    frozenset[AnsiColorType], frozenset(colorbytes.__subclasses__())
+)
 _ANSI_FORMAT_MAP = {k: x for x in _ANSI_COLOR_TYPES for k in [x, x.alias]}
 
 
@@ -407,7 +411,9 @@ def _is_ansi_type(typ: type):
 def sgr_re_pattern():
     uint8_re = r"(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)"
     ansicolor_re = f"[3-4]8;(?:2(?:;{uint8_re}){{3}}|5;{uint8_re})"
-    sgr_param_re = rf"(?:{ansicolor_re}|10[0-7]|9[0-7]|6[0-3]|5[02-5]|2[0-68-9]|[13-4]\d|\d)"
+    sgr_param_re = (
+        rf"(?:{ansicolor_re}|10[0-7]|9[0-7]|6[0-3]|5[02-5]|2[0-68-9]|[13-4]\d|\d)"
+    )
 
     return re.compile(rf"\x1b\[(?:{sgr_param_re}(?:;{sgr_param_re})*)?m")
 
@@ -436,7 +442,10 @@ def _split_ansi_escape(__s: str) -> list[tuple['SgrSequence', str]] | None:
     out = tmp
     if out and len(out) % 2 != 0:
         out.append({SgrSequence: str, str: SgrSequence}[type(out[-1])]())
-    return [(a, b) if isinstance(a, SgrSequence) else (b, a) for a, b in zip(out[::2], out[1::2])]
+    return [
+        (a, b) if isinstance(a, SgrSequence) else (b, a)
+        for a, b in zip(out[::2], out[1::2])
+    ]
 
 
 def _unwrap_ansi_escape(__b: bytes | bytearray):
@@ -458,10 +467,12 @@ def get_ansi_type(typ):
             from .._typing import unionize
 
             repr_getter = lambda t: (t if isinstance(t, type) else type(t))
-            msg = "Expected {.__name__!r} or {}, got {.__name__!r} object instead".format(
-                str,
-                type[unionize(set(map(repr_getter, _ANSI_FORMAT_MAP.values())))],
-                repr_getter(typ),
+            msg = (
+                "Expected {.__name__!r} or {}, got {.__name__!r} object instead".format(
+                    str,
+                    type[unionize(set(map(repr_getter, _ANSI_FORMAT_MAP.values())))],
+                    repr_getter(typ),
+                )
             )
             err = TypeError(msg)
         err.__cause__ = e.__cause__
@@ -597,10 +608,17 @@ def _get_sgr_nums(__x: bytes) -> list[int]:
     """
     if __x.isdigit():
         return [int(__x)]
-    __x = __x.removeprefix(CSI)[: idx if ~(idx := __x.find(0x6D)) else None].removesuffix(b'm')
+    __x = __x.removeprefix(CSI)[
+        : idx if ~(idx := __x.find(0x6D)) else None
+    ].removesuffix(b'm')
     length = len(__x)
     mask_indices = enumerate(
-        map(bool, int.to_bytes(~int.from_bytes(b';' * length) & int.from_bytes(__x), length=length))
+        map(
+            bool,
+            int.to_bytes(
+                ~int.from_bytes(b';' * length) & int.from_bytes(__x), length=length
+            ),
+        )
     )
     res = []
     buf = bytearray()
@@ -645,7 +663,9 @@ def _iter_normalized_sgr[_T: (
                 )
 
 
-def _co_yield_colorbytes(__iter: Iterator[int]) -> Generator[bytes | AnsiColorFormat, int, None]:
+def _co_yield_colorbytes(
+    __iter: Iterator[int],
+) -> Generator[bytes | AnsiColorFormat, int, None]:
     d: dict[int, ColorDictKeys] = {38: 'fg', 48: 'bg'}
     obj = b''
     while True:
@@ -737,7 +757,8 @@ class SgrSequence(MutableSequence[SgrParamBuffer]):
     def ansi_type(self):
         if self.is_color():
             typ, _ = max(
-                Counter(type(x._value) for x in self if x.is_color()).items(), key=lambda x: x[1]
+                Counter(type(x._value) for x in self if x.is_color()).items(),
+                key=lambda x: x[1],
             )
             return typ
 
@@ -751,7 +772,8 @@ class SgrSequence(MutableSequence[SgrParamBuffer]):
                 )
             case ColorStr():
                 return color_chain._from_masks_unchecked(
-                    [(self, ''), (other._sgr, other.base_str)], self.ansi_type() or DEFAULT_ANSI
+                    [(self, ''), (other._sgr, other.base_str)],
+                    self.ansi_type() or DEFAULT_ANSI,
                 )
             case str():
                 return ColorStr(f"{self}{other}")
@@ -831,7 +853,9 @@ class SgrSequence(MutableSequence[SgrParamBuffer]):
                 elts[SgrParamBuffer(elt)] = None
 
             self._sgr_params = list(elts)
-            self._rgb_dict = {k: v for xs in colors.values() for k, v in xs._rgb_dict.items()}
+            self._rgb_dict = {
+                k: v for xs in colors.values() for k, v in xs._rgb_dict.items()
+            }
 
     def __iter__(self):
         return iter(self._sgr_params)
@@ -850,7 +874,9 @@ class SgrSequence(MutableSequence[SgrParamBuffer]):
             __value: ...
             xs = list(_iter_sgr(__value))
             if len(xs) != 1:
-                err = ValueError(f"parsed {len(xs)} sgr parameters, expected only 1: {xs!r}")
+                err = ValueError(
+                    f"parsed {len(xs)} sgr parameters, expected only 1: {xs!r}"
+                )
                 raise err
             self._sgr_params[__index] = SgrParamBuffer(xs.pop())
         self._update_colors()
@@ -1009,19 +1035,29 @@ def _make_colorstr[_T: ColorStr](cls: type[_T], obj=_unset, *args, **kwargs) ->
         else:
             [typ] = e.args
             err = TypeError(
-                "expected integer or vector of 3 integers, " f"got {typ.__name__!r} object instead"
+                "expected integer or vector of 3 integers, "
+                f"got {typ.__name__!r} object instead"
             )
         err.__cause__ = e.__cause__
         raise err
-    inst: Any = str.__new__(cls, ''.join([str(sgr), base_str, SGR_RESET_S if reset else '']))
-    inst.__dict__ |= {'_sgr': sgr, '_base_str': base_str, '_ansi_type': ansi_type, '_reset': reset}
+    inst: Any = str.__new__(
+        cls, ''.join([str(sgr), base_str, SGR_RESET_S if reset else ''])
+    )
+    inst.__dict__ |= {
+        '_sgr': sgr,
+        '_base_str': base_str,
+        '_ansi_type': ansi_type,
+        '_reset': reset,
+    }
     return inst
 
 
 class ColorStr(str):
     def _weak_var_update(self, **kwargs):
         if not kwargs.keys() <= {'base_str', 'sgr', 'reset'}:
-            raise ValueError(f'unexpected keys: {(kwargs.keys() - {'base_str', 'sgr', 'reset'})}')
+            raise ValueError(
+                f'unexpected keys: {(kwargs.keys() - {'base_str', 'sgr', 'reset'})}'
+            )
         sgr = kwargs.get('sgr', self._sgr)
         base_str = kwargs.get('base_str', self.base_str)
         suffix = SGR_RESET_S if kwargs.get('reset', self.reset) else ''
@@ -1055,7 +1091,8 @@ class ColorStr(str):
             sgr = SgrSequence(self._sgr)
             sgr.rgb_dict = sgr._rgb_dict, ansi_type
             inst = str.__new__(
-                type(self), ''.join([str(sgr), self.base_str, SGR_RESET_S if self.reset else ''])
+                type(self),
+                ''.join([str(sgr), self.base_str, SGR_RESET_S if self.reset else '']),
             )
             inst.__dict__ |= vars(self) | {'_sgr': sgr, '_ansi_type': ansi_type}
             return inst
@@ -1122,7 +1159,9 @@ class ColorStr(str):
             ('Red text', '0x00FF00')
         """
         if not kwargs.keys() <= {'absolute', 'fg', 'bg'}:
-            raise ValueError(f"unexpected keywords: {(kwargs.keys() - {'absolute', 'fg', 'bg'})}")
+            raise ValueError(
+                f"unexpected keywords: {(kwargs.keys() - {'absolute', 'fg', 'bg'})}"
+            )
         if kwargs.pop('absolute', False):
             if not (args or kwargs):
                 return (
@@ -1167,14 +1206,18 @@ class ColorStr(str):
             if b'%d' % SgrParameter.DOUBLE_UNDERLINE in self._sgr:
                 return self
             elif b'%d' % SgrParameter.SINGLE_UNDERLINE in self._sgr:
-                return self.update_sgr(SgrParameter.SINGLE_UNDERLINE, SgrParameter.DOUBLE_UNDERLINE)
+                return self.update_sgr(
+                    SgrParameter.SINGLE_UNDERLINE, SgrParameter.DOUBLE_UNDERLINE
+                )
             else:
                 return self.update_sgr(SgrParameter.DOUBLE_UNDERLINE)
         else:
             if b'%d' % SgrParameter.SINGLE_UNDERLINE in self._sgr:
                 return self
             elif b'%d' % SgrParameter.DOUBLE_UNDERLINE in self._sgr:
-                return self.update_sgr(SgrParameter.DOUBLE_UNDERLINE, SgrParameter.SINGLE_UNDERLINE)
+                return self.update_sgr(
+                    SgrParameter.DOUBLE_UNDERLINE, SgrParameter.SINGLE_UNDERLINE
+                )
             else:
                 return self.update_sgr(SgrParameter.SINGLE_UNDERLINE)
 
@@ -1245,7 +1288,8 @@ class ColorStr(str):
             else:
                 sgr.append(bx)
         inst = super().__new__(
-            type(self), ''.join([str(sgr), self.base_str, SGR_RESET_S if self.reset else ''])
+            type(self),
+            ''.join([str(sgr), self.base_str, SGR_RESET_S if self.reset else '']),
         )
         inst.__dict__ |= vars(self) | {
             '_sgr': sgr,
@@ -1321,7 +1365,9 @@ class ColorStr(str):
 
     def join(self, __iterable):
         return self._weak_var_update(
-            base_str=self.base_str.join(getattr(elt, 'base_str', elt) for elt in __iterable)
+            base_str=self.base_str.join(
+                getattr(elt, 'base_str', elt) for elt in __iterable
+            )
         )
 
     def ljust(self, __width, __fillchar=" "):
@@ -1334,7 +1380,9 @@ class ColorStr(str):
         return self._weak_var_update(base_str=self.base_str.lstrip(__chars))
 
     def partition(self, __sep):
-        lhs, sep, rhs = (self._weak_var_update(base_str=s) for s in self.base_str.partition(__sep))
+        lhs, sep, rhs = (
+            self._weak_var_update(base_str=s) for s in self.base_str.partition(__sep)
+        )
         return lhs, sep, rhs
 
     def removeprefix(self, __prefix):
@@ -1344,7 +1392,9 @@ class ColorStr(str):
         return self._weak_var_update(base_str=self.base_str.removesuffix(__prefix))
 
     def replace(self, __old, __new, __count=-1):
-        return self._weak_var_update(base_str=self.base_str.replace(__old, __new, __count))
+        return self._weak_var_update(
+            base_str=self.base_str.replace(__old, __new, __count)
+        )
 
     def rfind(self, __sub, *args):
         return self.base_str.rfind(__sub, *args)
@@ -1359,7 +1409,9 @@ class ColorStr(str):
         return self._weak_var_update(base_str=self.base_str.rstrip(__chars))
 
     def rpartition(self, __sep):
-        lhs, sep, rhs = (self._weak_var_update(base_str=s) for s in self.base_str.rpartition(__sep))
+        lhs, sep, rhs = (
+            self._weak_var_update(base_str=s) for s in self.base_str.rpartition(__sep)
+        )
         return lhs, sep, rhs
 
     def rsplit(self, sep=None, maxsplit=-1):
@@ -1376,7 +1428,8 @@ class ColorStr(str):
 
     def splitlines(self, keepends=False):
         return [
-            self._weak_var_update(base_str=s) for s in self.base_str.splitlines(keepends=keepends)
+            self._weak_var_update(base_str=s)
+            for s in self.base_str.splitlines(keepends=keepends)
         ]
 
     def startswith(self, __prefix, *args):
@@ -1476,11 +1529,15 @@ class ColorStr(str):
         k: L['fg', 'bg']
         if isinstance(other, type(self)):
             xor_dict = {
-                k: int2rgb(Color.from_rgb(self.rgb_dict[k]) ^ Color.from_rgb(other.rgb_dict[k]))
+                k: int2rgb(
+                    Color.from_rgb(self.rgb_dict[k]) ^ Color.from_rgb(other.rgb_dict[k])
+                )
                 for k in self.rgb_dict.keys() & other.rgb_dict
             }
         elif isinstance(other, int):
-            xor_dict = {k: int2rgb(Color.from_rgb(v) ^ other) for k, v in self.rgb_dict.items()}
+            xor_dict = {
+                k: int2rgb(Color.from_rgb(v) ^ other) for k, v in self.rgb_dict.items()
+            }
         else:
             return NotImplemented
         if not xor_dict:
@@ -1596,7 +1653,10 @@ class color_chain:
         elif isinstance(other, str):
             if len(self._masks) > 0:
                 return self._from_masks_unchecked(
-                    [*self.masks[:-1], (self._masks[-1][0], self._masks[-1][1] + other)],
+                    [
+                        *self.masks[:-1],
+                        (self._masks[-1][0], self._masks[-1][1] + other),
+                    ],
                     ansi_type=self._ansi_type,
                 )
             return self._from_masks_unchecked(
@@ -1615,7 +1675,9 @@ class color_chain:
         if not kwargs.keys() <= {'fg', 'bg'}:
             raise ValueError
         sgr = SgrSequence(__sgr)
-        sgr.rgb_dict = {k: v for k, v in kwargs.items() if v is not None}, self._ansi_type
+        sgr.rgb_dict = {
+            k: v for k, v in kwargs.items() if v is not None
+        }, self._ansi_type
         self._masks = [(sgr, '')]
 
     def __radd__(self, other):

chromatic/color/core.pyi

@@ -96,7 +96,9 @@ class colorbytes(bytes):
         RGBVectorLike,
     )](
         cls: type[_T],
-        __rgb: tuple[ColorDictKeys, _VT] | Mapping[L['fg'], _VT] | Mapping[L['bg'], _VT],
+        __rgb: (
+            tuple[ColorDictKeys, _VT] | Mapping[L['fg'], _VT] | Mapping[L['bg'], _VT]
+        ),
     ) -> _T: ...
     @classmethod
     @overload
@@ -118,7 +120,9 @@ class colorbytes(bytes):
     @property
     def rgb_dict(
         self,
-    ) -> MappingProxyType[L['fg'], Int3Tuple] | MappingProxyType[L['bg'], Int3Tuple]: ...
+    ) -> (
+        MappingProxyType[L['fg'], Int3Tuple] | MappingProxyType[L['bg'], Int3Tuple]
+    ): ...
 
 class ColorStr(str):
     def _weak_var_update(self, **kwargs: Unpack[_ColorStrWeakVars]) -> Self: ...
@@ -138,7 +142,11 @@ class ColorStr(str):
     def casefold(self) -> Self: ...
     def center(self, width, fillchar=' ') -> Self: ...
     def count(
-        self, x: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ..., /
+        self,
+        x: str,
+        __start: SupportsIndex | None = ...,
+        __end: SupportsIndex | None = ...,
+        /,
     ): ...
     def endswith(
         self,
@@ -149,12 +157,20 @@ class ColorStr(str):
     ) -> bool: ...
     def expandtabs(self, /, tabsize=8) -> Self: ...
     def find(
-        self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ..., /
+        self,
+        __sub: str,
+        __start: SupportsIndex | None = ...,
+        __end: SupportsIndex | None = ...,
+        /,
     ) -> int: ...
     def format(self, *args, **kwargs) -> Self: ...
     def format_map(self, __mapping: Mapping[str, object], /) -> Self: ...
     def index(
-        self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ..., /
+        self,
+        __sub: str,
+        __start: SupportsIndex | None = ...,
+        __end: SupportsIndex | None = ...,
+        /,
     ) -> int: ...
     def join(self, __iterable: Iterable[str]) -> Self: ...
     def ljust(self, __width: SupportsIndex, __fillchar=' ') -> Self: ...
@@ -165,10 +181,18 @@ class ColorStr(str):
     def removesuffix(self, __suffix: str, /) -> Self: ...
     def replace(self, __old: str, __new: str, __count: SupportsIndex = -1) -> Self: ...
     def rfind(
-        self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ..., /
+        self,
+        __sub: str,
+        __start: SupportsIndex | None = ...,
+        __end: SupportsIndex | None = ...,
+        /,
     ) -> int: ...
     def rindex(
-        self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ..., /
+        self,
+        __sub: str,
+        __start: SupportsIndex | None = ...,
+        __end: SupportsIndex | None = ...,
+        /,
     ) -> int: ...
     def rjust(self, __width: SupportsIndex, __fillchar=' ') -> Self: ...
     def rpartition(self, __sep: str) -> TupleOf3[Self]: ...
@@ -255,16 +279,30 @@ class color_chain:
     ) -> Self: ...
     @classmethod
     def from_masks(
-        cls, masks: Sequence[tuple[SgrSequence, str]], ansi_type: type[AnsiColorFormat] = None
+        cls,
+        masks: Sequence[tuple[SgrSequence, str]],
+        ansi_type: type[AnsiColorFormat] = None,
     ) -> Self: ...
-    def __add__[_T: (color_chain, SgrSequence, ColorStr, str)](self, other: _T) -> color_chain: ...
+    def __add__[_T: (
+        color_chain,
+        SgrSequence,
+        ColorStr,
+        str,
+    )](self, other: _T) -> color_chain: ...
     def __call__(self, __obj=None) -> str: ...
     def __init__[_T: (
         int,
         Buffer,
         SgrParamBuffer,
-    )](self, __sgr: Iterable[_T] = ..., **kwargs: Unpack[_ColorChainKwargs]) -> None: ...
-    def __radd__[_T: (color_chain, SgrSequence, ColorStr, str)](self, other: _T) -> color_chain: ...
+    )](
+        self, __sgr: Iterable[_T] = ..., **kwargs: Unpack[_ColorChainKwargs]
+    ) -> None: ...
+    def __radd__[_T: (
+        color_chain,
+        SgrSequence,
+        ColorStr,
+        str,
+    )](self, other: _T) -> color_chain: ...
 
     _ansi_type: type[AnsiColorFormat]
     _masks: list[tuple[SgrSequence, str]]
@@ -355,7 +393,9 @@ class SgrParamBuffer[
     def is_reset(self) -> bool: ...
     def __buffer__(self, __flags: int) -> memoryview: ...
     def __bytes__(self) -> bytes: ...
-    def __eq__[_T](self: SgrParamBuffer[_T], other) -> TypeIs[SgrParamBuffer[_T] | _T]: ...
+    def __eq__[_T](
+        self: SgrParamBuffer[_T], other
+    ) -> TypeIs[SgrParamBuffer[_T] | _T]: ...
     def __hash__(self) -> int: ...
     @overload
     def __new__(cls, __value: _T = ...) -> Self: ...
@@ -394,14 +434,20 @@ class SgrSequence(MutableSequence[SgrParamBuffer]):
     @overload
     def __getitem__(self, __index: SupportsIndex) -> SgrParamBuffer: ...
     @overload
-    def __setitem__(self, __index: slice, __value: Iterable[bytes | SgrParamBuffer]): ...
+    def __setitem__(
+        self, __index: slice, __value: Iterable[bytes | SgrParamBuffer]
+    ): ...
     @overload
     def __setitem__(self, __index: SupportsIndex, __value: bytes | SgrParamBuffer): ...
     @overload
     def __delitem__(self, __index: slice): ...
     @overload
     def __delitem__(self, __index: SupportsIndex): ...
-    def __init__[_T: (int, Buffer, SgrParamBuffer)](self, __iter: Iterable[_T] = ...): ...
+    def __init__[_T: (
+        int,
+        Buffer,
+        SgrParamBuffer,
+    )](self, __iter: Iterable[_T] = ...): ...
     def __iter__(self) -> Iterator[SgrParamBuffer]: ...
 
     __slots__ = '_rgb_dict', '_sgr_params'
@@ -421,7 +467,9 @@ class SgrSequence(MutableSequence[SgrParamBuffer]):
     def rgb_dict(self, __value: dict[ColorDictKeys, Int3Tuple | None]): ...
     @overload
     @rgb_dict.setter  # type: ignore[no-redef]
-    def rgb_dict(self, __value: tuple[dict[ColorDictKeys, Int3Tuple | None], AnsiColorType]): ...
+    def rgb_dict(
+        self, __value: tuple[dict[ColorDictKeys, Int3Tuple | None], AnsiColorType]
+    ): ...
 
 class _RecolorKwargs(TypedDict, total=False):
     absolute: bool