chromatic-python 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

chromatic/__init__.py

@@ -7,6 +7,7 @@ from . import ascii, color, data
 from .ascii import (
     AnsiImage,
     ansi2img,
+    ansify,
     ansi_quantize,
     ascii2img,
     ascii_printable,
@@ -40,3 +41,69 @@ from .color import (
 from .data import register_user_font
 
 __all__ = []
+
+try:
+    import os
+    import sys
+    from functools import lru_cache, wraps
+    from types import ModuleType
+
+    def find_modules(path: str):
+        from setuptools import find_packages
+        from pkgutil import iter_modules
+
+        tree: dict[str, dict | ModuleType] = {__name__: {'__module__': sys.modules[__name__]}}
+        children = set()
+        for pkg in find_packages(path):
+            children.add(pkg)
+            pkg_path = path + '/' + pkg.replace('.', '/')
+            if sys.version_info.major == 2 or (
+                sys.version_info.major == 3 and sys.version_info.minor < 6
+            ):
+                for _, name, ispkg in iter_modules([pkg_path]):
+                    if not ispkg:
+                        children.add(f"{pkg}.{name}")
+            else:
+                for info in iter_modules([pkg_path]):
+                    if not info.ispkg:
+                        children.add(f"{pkg}.{info.name}")
+        for child in children:
+            name = f"{__name__}.{child}"
+            depth = tree
+            for node in name.split('.'):
+                if node not in depth:
+                    depth[node] = {}
+                depth = depth[node]
+            if name in sys.modules:
+                depth['__module__'] = sys.modules[name]
+        return tree
+
+    def publicize_modules(modulename: str, tree: dict[str, dict | ModuleType]):
+        def is_local(obj: object):
+            if isinstance(obj, ModuleType):
+                return obj.__spec__.parent == modulename
+            elif hasattr(obj, '__module__'):
+                return obj.__module__ == modulename
+            return obj is not None
+
+        for name, subtree in tree.items():
+            if name == '__module__' and isinstance(subtree, ModuleType):
+                submodule = subtree
+                init_dir = dir(submodule)
+
+                @wraps(submodule.__dir__)
+                def wrapped():
+                    s = set(attr for attr in init_dir if is_local(getattr(submodule, attr, None)))
+                    if hasattr(submodule, '__all__'):
+                        s.update(submodule.__all__)
+                    return list(s)
+
+                sys.modules[submodule.__name__].__dir__ = wrapped
+
+            else:
+                publicize_modules(f"{modulename}.{name}", subtree)
+
+    publicize_modules(*find_modules(os.path.split(__file__)[0]).popitem())
+
+finally:
+    del find_modules, publicize_modules

chromatic/_typing.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import inspect
+import operator as op
 import re
 import types
 from collections import OrderedDict, namedtuple
 from collections.abc import Callable as ABC_Callable
 from functools import reduce, wraps
 from numbers import Number
-from operator import attrgetter, or_ as bitwise_or
 from typing import (
     Any,
     Callable,
@@ -79,7 +79,7 @@ FontArgType: TypeAlias = FreeTypeFont | UserFont | str | int
 
 def type_error_msg(err_obj, *expected, context: str = '', obj_repr=False):
     n_expected = len(expected)
-    name_slots = [f"{{{n}.__qualname__!r}}" for n in range(n_expected)]
+    name_slots = ['{%d.__qualname__!r}' % n for n in range(n_expected)]
     if name_slots and n_expected > 1:
         name_slots[-1] = f"or {name_slots[-1]}"
     names = (', ' if n_expected > 2 else ' ').join([context.strip()] + name_slots).format(*expected)
@@ -183,7 +183,7 @@ class SupportsUnion(Protocol[_T_contra, _T_co]):
 
 
 def unionize(__iterable: Iterable[SupportsUnion[_T_contra, _T_co]]) -> _T_co:
-    return reduce(bitwise_or, __iterable)
+    return reduce(op.or_, __iterable)
 
 
 _GenericAlias = type(Type[...]) | types.GenericAlias
@@ -213,7 +213,7 @@ class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
 
 
 _SUBTYPE_CACHE: _BoundedDict[int, ...] = _BoundedDict()
-_ATTR_GETTERS: _BoundedDict[..., tuple[Callable[[Iterable], NamedTuple], attrgetter]] = (
+_ATTR_GETTERS: _BoundedDict[..., tuple[Callable[[Iterable], NamedTuple], op.attrgetter]] = (
     _BoundedDict()
 )
 
@@ -247,7 +247,10 @@ def _unique_attrs(obj) -> Optional['NamedTuple']:
         + 'Attrs'
     ).strip('_')
     UniqueAttrs = cast(NamedTuple, namedtuple(tup_name, field_names))
-    _ATTR_GETTERS[tp] = constructor, getter = UniqueAttrs._make, attrgetter(*attr_names)  # noqa
+    _ATTR_GETTERS[tp] = [constructor, getter] = [
+        UniqueAttrs._make,
+        op.attrgetter(*attr_names),  # noqa
+    ]
     return constructor(getter(obj))
 
 

chromatic/_version.py

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

chromatic/ascii/_array.py

@@ -1,5 +1,29 @@
 from __future__ import annotations
 
+__all__ = [
+    'ansi2img',
+    'ansify',
+    'ansi_quantize',
+    'ascii2img',
+    'contrast_stretch',
+    'equalize_white_point',
+    'get_font_key',
+    'get_font_object',
+    'img2ansi',
+    'img2ascii',
+    'read_ans',
+    'render_ans',
+    'render_font_char',
+    'render_font_str',
+    'reshape_ansi',
+    'scale_saturation',
+    'shuffle_char_set',
+    '_scaled_hu_moments',
+    'to_sgr_array',
+    'AnsiImage',
+    '_otsu_mask',
+]
+
 import math
 import os.path
 import random
@@ -62,29 +86,6 @@ from ..data import UserFont
 if TYPE_CHECKING:
     from _typeshed import AnyStr_co
 
-__all__ = [
-    'ansi2img',
-    'ansi_quantize',
-    'ascii2img',
-    'contrast_stretch',
-    'equalize_white_point',
-    'get_font_key',
-    'get_font_object',
-    'img2ansi',
-    'img2ascii',
-    'read_ans',
-    'render_ans',
-    'render_font_char',
-    'render_font_str',
-    'reshape_ansi',
-    'scale_saturation',
-    'shuffle_char_set',
-    '_scaled_hu_moments',
-    'to_sgr_array',
-    'AnsiImage',
-    '_otsu_mask',
-]
-
 
 def get_font_key(font: FreeTypeFont):
     """Obtain a unique tuple pair from a FreeTypeFont object.
@@ -597,6 +598,7 @@ def img2ascii(
     return ascii_str
 
 
+@rgb_dispatch
 def img2ansi(
     __img: RGBImageLike | PathLike[str] | str,
     __font: FontArgType = 'arial.ttf',
@@ -605,7 +607,7 @@ def img2ansi(
     ansi_type: AnsiColorParam = DEFAULT_ANSI,
     sort_glyphs: bool | type[reversed] = True,
     equalize: bool | Literal['white_point'] = True,
-    bg: Color | Int3Tuple = (0, 0, 0),
+    bg: Color | Int3Tuple | str = (0, 0, 0),
 ):
     """Convert an image to an ANSI array.
 
@@ -665,7 +667,7 @@ def img2ansi(
     """
     if ansi_type is not DEFAULT_ANSI:
         ansi_type = get_ansi_type(ansi_type)
-    bg_wrapper = ColorStr('{}', color_spec={'bg': bg}, ansi_type=ansi_type, no_reset=True)
+    bg_wrapper = ColorStr('{}', color_spec={'bg': bg}, ansi_type=ansi_type, reset=False)
     base_ascii, color_arr = img2ascii(__img, __font, factor, char_set, sort_glyphs, ret_img=True)
     lines = base_ascii.splitlines()
     h, w = map(len, (lines, lines[0]))
@@ -697,7 +699,7 @@ def ascii2img(
     font_size=24,
     *,
     fg: Int3Tuple | str = (0, 0, 0),
-    bg: Int3Tuple | str = (255, 255, 255),
+    bg: Int3Tuple | str = (0xFF, 0xFF, 0xFF),
 ):
     """Render a literal string as an image.
 
@@ -803,7 +805,7 @@ def ansi2img(
         x_offset = 0
         for color_str in row:
             text_width = font.getbbox(color_str.base_str)[2]
-            if color_str._sgr_.is_reset():
+            if getattr(color_str, '_sgr_').is_reset():
                 fg_default = None
                 bg_default = input_bg
             if fg_color := getattr(color_str.fg, 'rgb', fg_default):
@@ -823,6 +825,38 @@ def ansi2img(
     return img
 
 
+def ansify(
+    __img: RGBImageLike | PathLike[str] | str,
+    /,
+    *,
+    font: FontArgType = UserFont.IBM_VGA_437_8X16,
+    font_size: int = 16,
+    factor: int = 200,
+    char_set: Iterable[str] = None,
+    sort_glyphs: bool | type[reversed] = True,
+    ansi_type: AnsiColorParam = DEFAULT_ANSI,
+    equalize: bool | Literal['white_point'] = True,
+    fg: Int3Tuple | str = (170, 170, 170),
+    bg: Int3Tuple | str | Literal['auto'] = (0, 0, 0),
+):
+    return ansi2img(
+        img2ansi(
+            __img,
+            font,
+            factor=factor,
+            char_set=char_set,
+            ansi_type=ansi_type,
+            sort_glyphs=sort_glyphs,
+            equalize=equalize,
+            bg=bg,
+        ),
+        font,
+        font_size=font_size,
+        fg_default=fg,
+        bg_default=bg,
+    )
+
+
 def _is_array(__obj: Any) -> TypeGuard[ndarray]:
     return isinstance(__obj, ndarray)
 
@@ -913,6 +947,7 @@ def to_sgr_array(__str: str, ansi_type: AnsiColorParam = DEFAULT_ANSI):
     resets = frozenset(resets_btok)
     pad_esc = {0x1B: '\x00\x1b'}
     x = []
+    sgr: SgrSequence | None
     for line in __str.splitlines():
         xs = []
         ansi_meta = {}
@@ -927,7 +962,7 @@ def to_sgr_array(__str: str, ansi_type: AnsiColorParam = DEFAULT_ANSI):
             else:
                 cs = new_cs(s)
             if sgr is None:
-                sgr = cs._sgr_
+                sgr: SgrSequence = getattr(cs, '_sgr_')
             if sgr.is_reset():
                 ansi_meta.clear()
             for k in resets.intersection(sgr.values()):
@@ -947,7 +982,7 @@ def to_sgr_array(__str: str, ansi_type: AnsiColorParam = DEFAULT_ANSI):
                     if not ansi_meta.get('bright'):
                         ansi_meta['bright'] = True
                     new_sgr = SgrSequence(
-                        sgr.values() + [p._value_ for p in prev._sgr_ if p.is_color()]
+                        sgr.values() + [p._value_ for p in getattr(prev, '_sgr_') if p.is_color()]
                     )
                     prev = cs = new_cs(cs.base_str, new_sgr)
             xs.append(cs.as_ansi_type(ansi_typ))
@@ -1009,9 +1044,10 @@ def read_ans[AnyStr: (str, bytes)](__path: PathLike[AnyStr] | AnyStr, encoding='
 class AnsiImage:
 
     @classmethod
-    def open[
-        AnyStr: (str, bytes)
-    ](
+    def open[AnyStr: (
+        str,
+        bytes,
+    )](
         cls,
         fp: PathLike[AnyStr] | AnyStr,
         shape: TupleOf2[int],
@@ -1076,7 +1112,7 @@ class AnsiImage:
         if not __table:
             return self
         table = {
-            k: (v if v not in frozenset(x for c in ' \t\n\r\v\f' for x in (c, ord(c))) else ' ')
+            k: v if v not in frozenset(x for c in ' \t\n\r\v\f' for x in (c, ord(c))) else ' '
             for (k, v) in __table.items()
             if k != ord('\n')
         }
@@ -1098,8 +1134,8 @@ class AnsiImage:
             return getattr(self, attr_name)[0]
         lines = []
         for line in self.data:
-            buffer = []
             if line:
+                buffer = []
                 initial = line[0]
                 for s in line[1:]:
                     if s.ansi_partition()[::2] == initial.ansi_partition()[::2]:
@@ -1109,7 +1145,7 @@ class AnsiImage:
                         initial = s
                 buffer.append(initial)
                 lines.append(''.join(buffer))
-        setattr(self, attr_name, ('\n'.join(lines) + SGR_RESET, self.shape))
+        setattr(self, attr_name, ('\n'.join(lines) + SGR_RESET.decode(), self.shape))
         return getattr(self, attr_name)[0]
 
 

chromatic/color/core.py

@@ -61,7 +61,8 @@ from .._typing import (
 os.system('')
 
 CSI: Final[bytes] = b'['
-SGR_RESET: Final[str] = ''
+SGR_RESET: Final[bytes] = b''
+SGR_RESET_S: Final[str] = SGR_RESET.decode()
 
 # ansi color global lookups
 # ansi 4bit {color code (int) ==> (key, RGB)}
@@ -503,7 +504,8 @@ def get_ansi_type(typ):
 
 def rgb2ansi_escape(ret_format, mode, rgb):
     ret_format = get_ansi_type(ret_format)
-    assert len(rgb) == 3, 'length of RGB value is not 3'
+    if len(rgb) != 3:
+        raise ValueError('length of RGB value is not 3')
     try:
         if ret_format is ansicolor4Bit:
             return b'%d' % _ANSI16C_KV2I[mode, nearest_ansi_4bit_rgb(rgb)]
@@ -633,9 +635,11 @@ def _get_sgr_bitmask[_T: (bytes, bytearray, Buffer)](__x: _T) -> list[int]:
     return allocated
 
 
-def _iter_normalized_sgr[
-    _T: (Buffer, SgrParamWrapper, int)
-](__iter: Buffer | Iterable[_T]) -> Iterator[AnsiColorFormat | int]:
+def _iter_normalized_sgr[_T: (
+    Buffer,
+    SgrParamWrapper,
+    int,
+)](__iter: Buffer | Iterable[_T]) -> Iterator[AnsiColorFormat | int]:
     if isinstance(__iter, Buffer):
         yield from _get_sgr_bitmask(__iter)
     else:
@@ -894,7 +898,8 @@ class SgrSequence(Sequence[SgrParamWrapper]):
         if ansi_type is None:
             is_diff_ansi_typ = lambda _: False
         else:
-            assert ansi_type in _ANSI_COLOR_TYPES
+            if ansi_type not in _ANSI_COLOR_TYPES:
+                raise TypeError
             is_diff_ansi_typ = lambda v: type(v) is not ansi_type
 
         for x in _iter_sgr(__iter):
@@ -1013,15 +1018,17 @@ _VALID_KEYS: frozenset[str] = unionize(
 )
 
 
-def _solve_color_spec[
-    _T: (_CSpecType, SgrSequence)
-](color_spec: Optional[_T], ansi_type: AnsiColorType):
+def _solve_color_spec[_ColorSpec: (
+    _CSpecType,
+    SgrSequence,
+)](color_spec: Optional[_ColorSpec], ansi_type: AnsiColorType):
     keys: list[str] = ['bg', 'fg']
 
     def resolve(value, *, key=None):
         nonlocal keys
         if key is not None:
-            assert key in _VALID_KEYS, 'expected literal keys {}, got {!r}'.format(_VALID_KEYS, key)
+            if key not in _VALID_KEYS:
+                raise ValueError(f"expected one of {_VALID_KEYS}, got {key!r}")
             if key in keys:
                 keys.remove(key)
         match value:
@@ -1031,7 +1038,8 @@ def _solve_color_spec[
                 r, g, b = (x & 0xFF for x in rgb)
                 yield (key or keys.pop(), (r, g, b))
             case np.ndarray() as colors:
-                assert not colors.shape[-1] % 3, 'array does not contain RGB values'
+                if colors.shape[-1] % 3 != 0:
+                    raise ValueError('array does not contain RGB values')
                 it = np.uint8(colors).flat
                 for _ in range(colors.ndim):
                     yield (key or keys.pop(), tuple(int(next(it)) for _ in range(3)))
@@ -1076,7 +1084,7 @@ def _get_color_str_vars(
         if csi_count := color_spec.count(CSI):
             if csi_count > 1:
                 color_spec, _, byte_str = (
-                    color_spec.removeprefix(CSI).removesuffix(SGR_RESET.encode()).partition(b'm')
+                    color_spec.removeprefix(CSI).removesuffix(SGR_RESET).partition(b'm')
                 )
                 if color_spec.count(CSI) > 1:
                     raise ValueError(
@@ -1095,26 +1103,12 @@ def _get_color_str_vars(
     return sgr_params, base_str
 
 
-class _ColorStrWeakVars(TypedDict, total=False):
-    _base_str_: str
-    _sgr_: SgrSequence
-    _no_reset_: bool
-
-
 class _AnsiBytesGetter:
 
     def __get__(self, instance: Optional['ColorStr'], objtype=None):
         if instance is None:
             return
-        return instance._sgr_.__bytes__()
-
-
-class _SgrParamsGetter:
-
-    def __get__(self, instance: Optional['ColorStr'], objtype=None):
-        if instance is None:
-            return
-        return instance._sgr_._sgr_params_
+        return bytes(getattr(instance, '_sgr_'))
 
 
 class _ColorDictGetter:
@@ -1122,7 +1116,7 @@ class _ColorDictGetter:
     def __get__(self, instance: Optional['ColorStr'], objtype=None):
         if instance is None:
             return
-        return {k: Color.from_rgb(v) for k, v in instance._sgr_.rgb_dict.items()}
+        return {k: Color.from_rgb(v) for k, v in getattr(instance, '_sgr_').rgb_dict.items()}
 
 
 class ColorStr(str):
@@ -1130,16 +1124,16 @@ class ColorStr(str):
     def _weak_var_update(self, **kwargs):
         if kwargs.keys().isdisjoint(inst_vars := vars(self)):
             raise ValueError(f"unexpected keys: {kwargs.keys() - inst_vars.keys()}") from None
-        sgr = kwargs.get('_sgr_', self._sgr_)
-        base_str = kwargs.get('_base_str_', self._base_str_)
-        suffix = '' if kwargs.get('_no_reset_', self._no_reset_) else SGR_RESET
+        sgr = kwargs.get('_sgr_', getattr(self, '_sgr_'))
+        base_str = kwargs.get('_base_str_', self.base_str)
+        suffix = SGR_RESET_S if kwargs.get('_reset_', self.reset) else ''
         inst = super().__new__(ColorStr, ''.join([str(sgr), base_str, suffix]))
-        inst.__dict__ |= {**inst_vars, **kwargs}
+        inst.__dict__ |= inst_vars | kwargs
         return cast(ColorStr, inst)
 
     def ansi_partition(self):
         """Returns the 3-tuple: SGR sequence prefix, base string, SGR reset (or empty string)."""
-        return str(self._sgr_), self.base_str, '' if self.no_reset else SGR_RESET
+        return str(getattr(self, '_sgr_')), self.base_str, SGR_RESET_S if self.reset else ''
 
     def as_ansi_type(self, __ansi_type):
         """Convert all ANSI color codes in the :class:`ColorStr` to a single ANSI type.
@@ -1157,24 +1151,24 @@ class ColorStr(str):
 
         """
         ansi_type = get_ansi_type(__ansi_type)
-        if self._sgr_.is_color():
+        if getattr(self, '_sgr_').is_color():
             new_params = []
             new_rgb = {}
-            for p in self._sgr_params_:
+            for p in getattr(self, '_sgr_'):
                 if p.is_color() and type(p._value_) is not ansi_type:
                     new_ansi = ansi_type(p._value_)
                     new_rgb |= new_ansi.rgb_dict
                     new_params.append(SgrParamWrapper(new_ansi))
                 else:
                     new_params.append(p)
-            if new_params == self._sgr_params_:
+            if new_params == list(getattr(self, '_sgr_')):
                 return self
             new_sgr = SgrSequence()
             for name, value in zip(('_sgr_params_', '_rgb_dict_'), (new_params, new_rgb)):
                 setattr(new_sgr, name, value)
             inst = super().__new__(
                 type(self),
-                ''.join([str(new_sgr), self._base_str_, '' if self._no_reset_ else SGR_RESET]),
+                ''.join([str(new_sgr), self.base_str, SGR_RESET_S if self.reset else '']),
             )
             for name, value in {**vars(self), '_sgr_': new_sgr, '_ansi_type_': ansi_type}.items():
                 setattr(inst, name, value)
@@ -1241,7 +1235,7 @@ class ColorStr(str):
         """
         if __value:
             if isinstance(__value, ColorStr):
-                kwargs = __value._color_dict_
+                kwargs = getattr(__value, '_color_dict_')
             else:
                 raise TypeError(
                     f"expected positional argument of type {ColorStr.__qualname__!r}, "
@@ -1255,7 +1249,7 @@ class ColorStr(str):
                 kwargs = {k: v if v is None else Color(v) for k, v in kwargs.items()}
             except Exception as e:
                 raise e from None
-        sgr = SgrSequence(self._sgr_)
+        sgr = SgrSequence(getattr(self, '_sgr_'))
         if bool(absolute):
             del sgr.rgb_dict
         sgr.rgb_dict = (self.ansi_format, kwargs)
@@ -1297,7 +1291,7 @@ class ColorStr(str):
         Examples
         --------
         >>> # creating an empty ColorStr object
-        >>> empty_cs = ColorStr(no_reset=True)
+        >>> empty_cs = ColorStr(reset=True)
         >>> empty_cs.ansi
         b''
 
@@ -1327,7 +1321,7 @@ class ColorStr(str):
             return self
         if any(not isinstance(x, int) or x in _ANSI256_KEY2I.values() for x in p):
             raise ValueError
-        new_sgr = SgrSequence(self._sgr_)
+        new_sgr = SgrSequence(getattr(self, '_sgr_'))
         for x in p:
             if x in new_sgr:
                 new_sgr.pop(new_sgr.index(x))
@@ -1345,8 +1339,7 @@ class ColorStr(str):
         else:
             ansi_type = self.ansi_format
         inst = super().__new__(
-            type(self),
-            ''.join([str(new_sgr), self._base_str_, '' if self._no_reset_ else SGR_RESET]),
+            type(self), ''.join([str(new_sgr), self.base_str, SGR_RESET_S if self.reset else ''])
         )
         inst.__dict__ |= {**vars(self), '_sgr_': new_sgr, '_ansi_type_': ansi_type}
         return cast(ColorStr, inst)
@@ -1354,11 +1347,11 @@ class ColorStr(str):
     def __add__(self, other):
         if type(self) is type(other):
             return self._weak_var_update(
-                _sgr_=self._sgr_ + other._sgr_,
-                _base_str_=''.join([self._base_str_, other._base_str_]),
+                _sgr_=getattr(self, '_sgr_') + other._sgr_,
+                _base_str_=''.join([self.base_str, other._base_str_]),
             )
         if isinstance(other, str):
-            return self._weak_var_update(_base_str_=''.join([self._base_str_, other]))
+            return self._weak_var_update(_base_str_=''.join([self.base_str, other]))
         if isinstance(other, SgrParameter):
             return self.update_sgr(other)
         if hasattr(other, '_sgr_'):
@@ -1373,10 +1366,10 @@ class ColorStr(str):
     def __contains__(self, __key: str):
         if type(__key) is not str:
             return False
-        if __key == str(self._sgr_):
+        if __key == str(getattr(self, '_sgr_')):
             return True
-        if __key == SGR_RESET:
-            return not self.no_reset
+        if __key == SGR_RESET_S:
+            return self.reset
         return self.base_str.__contains__(__key)
 
     def __eq__(self, other):
@@ -1395,7 +1388,7 @@ class ColorStr(str):
         return self._weak_var_update(_base_str_=self.base_str[__key])
 
     def __hash__(self):
-        return str(self).__hash__()
+        return ''.join(self.ansi_partition()).__hash__()
 
     # noinspection PyUnusedLocal
     def __init__(self, obj=None, color_spec=None, **kwargs):
@@ -1429,9 +1422,9 @@ class ColorStr(str):
             * ANSI format can also be changed on instances using :meth:`ColorStr.as_ansi_type`
             * Reformatting recursively applies to `alt_spec` if `alt_spec` is not None
 
-        no_reset : bool
-            If True, create the :class:`ColorStr` without concatenating a 'reset all' SGR sequence.
-            Default is False (new instances get concatenated with reset sequences).
+        reset : bool
+            If False, create the :class:`ColorStr` without concatenating an SGR 'reset' sequence.
+            Default is True (new instances get concatenated with reset sequences).
 
         Returns
         -------
@@ -1479,10 +1472,10 @@ class ColorStr(str):
     def __matmul__(self, other):
         """Return a new :class:`ColorStr` with the base string of `self` and colors of `other`"""
         if type(self) is type(other):
-            return self._weak_var_update(_sgr_=other._sgr_, _no_reset_=other.no_reset)
+            return self._weak_var_update(_sgr_=getattr(other, '_sgr_'), _reset_=other.reset)
         raise TypeError(
             'unsupported operand type(s) for @: '
-            "{!r} and {!r}".format(*(type(x).__qualname__ for x in (self, other)))
+            "{.__qualname__!r} and {.__qualname__!r}".format(*map(type, (self, other)))
         )
 
     def __mod__(self, __value):
@@ -1493,8 +1486,8 @@ class ColorStr(str):
 
     def __invert__(self):
         """Return a copy of `self` with inverted colors (XORed by '0xFFFFFF')"""
-        sgr = SgrSequence(self._sgr_)
-        sgr.rgb_dict = (self.ansi_format, {k: ~v for k, v in self._color_dict_.items()})
+        sgr = SgrSequence(getattr(self, '_sgr_'))
+        sgr.rgb_dict = (self.ansi_format, {k: ~v for k, v in getattr(self, '_color_dict_').items()})
         return self._weak_var_update(_sgr_=sgr)
 
     def __new__(cls, obj=None, color_spec=None, **kwargs):
@@ -1507,9 +1500,11 @@ class ColorStr(str):
             for name, value in vars(color_spec).items():
                 setattr(inst, name, value)
             return inst
-        d = {'_ansi_type_': ansi_type or DEFAULT_ANSI}
-        no_reset = d['_no_reset_'] = bool(kwargs.get('no_reset', False))
-        suffix = '' if no_reset else SGR_RESET
+        d = {
+            '_ansi_type_': ansi_type or DEFAULT_ANSI,
+            '_reset_': bool(kwargs.get('reset', True)),
+        }
+        suffix = SGR_RESET_S if d['_reset_'] else ''
         if obj is not None:
             if not isinstance(obj, str):
                 obj = str(obj, encoding='ansi') if isinstance(obj, Buffer) else str(obj)
@@ -1559,48 +1554,47 @@ class ColorStr(str):
             }
         if not diff_dict:
             return self
-        sgr = SgrSequence(self._sgr_)
+        sgr = SgrSequence(getattr(self, '_sgr_'))
         sgr.rgb_dict = self.ansi_format, diff_dict
         return self._weak_var_update(_sgr_=sgr)
 
     _ansi_ = _AnsiBytesGetter()
     _color_dict_ = _ColorDictGetter()
-    _sgr_params_ = _SgrParamsGetter()
 
     @property
     def ansi(self):
-        return self._ansi_
+        return getattr(self, '_ansi_')
 
     @property
     def ansi_format(self):
-        return self._ansi_type_
+        return getattr(self, '_ansi_type_')
 
     @property
     def base_str(self):
         """The non-ANSI part of the string"""
-        return self._base_str_
+        return getattr(self, '_base_str_')
 
     @property
     def bg(self):
         """Background color"""
-        return self._color_dict_.get('bg')
+        return getattr(self, '_color_dict_').get('bg')
 
     @property
     def fg(self):
         """Foreground color"""
-        return self._color_dict_.get('fg')
+        return getattr(self, '_color_dict_').get('fg')
 
     @property
-    def no_reset(self):
-        return self._no_reset_
+    def reset(self):
+        return getattr(self, '_reset_')
 
     @property
     def rgb_dict(self):
-        return {k: v.rgb for k, v in self._color_dict_.items()}
+        return {k: v.rgb for k, v in getattr(self, '_color_dict_').items()}
 
 
 def _color_str_to_mask(cs: ColorStr) -> tuple[SgrSequence, str]:
-    return cs._sgr_, cs.base_str
+    return getattr(cs, '_sgr_'), cs.base_str
 
 
 class color_chain:
@@ -1728,7 +1722,7 @@ class color_chain:
 
     def __str__(self):
         return ''.join(
-            str(ColorStr(base_str, color_spec=sgr, ansi_type=self._ansi_type_, no_reset=True))
+            str(ColorStr(base_str, color_spec=sgr, ansi_type=self._ansi_type_, reset=False))
             for sgr, base_str in self.masks
         )
 

chromatic/color/core.pyi

@@ -99,7 +99,7 @@ class ColorStr(str):
     def __hash__(self) -> int: ...
     def __init__(
         self,
-        obj: object = None,
+        obj: object = ...,
         color_spec: Union[_ColorSpec, ColorStr] = None,
         **kwargs: Unpack[_ColorStrKwargs],
     ) -> None: ...
@@ -111,7 +111,7 @@ class ColorStr(str):
     def __invert__(self) -> ColorStr: ...
     def __new__(
         cls,
-        obj: object = None,
+        obj: object = ...,
         color_spec: Union[_ColorSpec, ColorStr] = None,
         **kwargs: Unpack[_ColorStrKwargs],
     ) -> ColorStr: ...
@@ -136,7 +136,7 @@ class ColorStr(str):
     @property
     def fg(self) -> Optional[Color]: ...
     @property
-    def no_reset(self) -> bool: ...
+    def reset(self) -> bool: ...
     @property
     def rgb_dict(self) -> dict[ColorDictKeys, Int3Tuple]: ...
 
@@ -277,9 +277,13 @@ class SgrSequence(Sequence[SgrParamWrapper]):
     def __getitem__(self, item: SupportsIndex) -> SgrParamWrapper: ...
     @overload
     def __getitem__(self, item: slice) -> list[SgrParamWrapper]: ...
-    def __init__[
-        _T: (SgrParamWrapper, Buffer, int), _AnsiType: type[AnsiColorFormat]
-    ](self, __iter: Iterable[_T] = None, *, ansi_type: _AnsiType = None) -> None: ...
+    def __init__[_T: (
+        SgrParamWrapper,
+        Buffer,
+        int,
+    ), _AnsiType: type[AnsiColorFormat]](
+        self, __iter: Iterable[_T] = None, *, ansi_type: _AnsiType = None
+    ) -> None: ...
     def __iter__(self) -> Iterator[SgrParamWrapper]: ...
     def __len__(self) -> int: ...
     def __radd__[_T: (SgrSequence, str)](self, other: _T) -> _T: ...
@@ -307,9 +311,9 @@ class SgrSequence(Sequence[SgrParamWrapper]):
 
     # noinspection PyUnresolvedReferences
     @rgb_dict.setter
-    def rgb_dict[
-        _AnsiColorType: type[AnsiColorFormat]
-    ](self, __value: tuple[_AnsiColorType, dict[ColorDictKeys, Optional[Color]]]) -> None: ...
+    def rgb_dict[_AnsiColorType: type[AnsiColorFormat]](
+        self, __value: tuple[_AnsiColorType, dict[ColorDictKeys, Optional[Color]]]
+    ) -> None: ...
 
 class _ColorDict(TypedDict, total=False):
     bg: Optional[Color | AnsiColorFormat]
@@ -317,15 +321,16 @@ class _ColorDict(TypedDict, total=False):
 
 class _ColorStrKwargs(TypedDict, total=False):
     ansi_type: Optional[AnsiColorAlias | type[AnsiColorFormat]]
-    no_reset: bool
+    reset: bool
 
 class _ColorStrWeakVars(TypedDict, total=False):
     _base_str_: str
-    _no_reset_: bool
+    _reset_: bool
     _sgr_: SgrSequence
 
-CSI: Final[bytes] = b'['
-SGR_RESET: Final[str] = ''
+CSI: Final[bytes]
+SGR_RESET: Final[bytes]
+SGR_RESET_S: Final[str]
 DEFAULT_ANSI: Final[type[ansicolor8Bit | ansicolor4Bit]]
 
 _ANSI16C_BRIGHT: Final[frozenset[int]]

chromatic/color/palette.py

@@ -1,4 +1,4 @@
-from functools import lru_cache, update_wrapper
+from functools import lru_cache, update_wrapper, wraps
 from inspect import getfullargspec, getmodule, isbuiltin, signature
 from types import FunctionType, MappingProxyType
 from typing import Callable, Iterator, Sequence, TYPE_CHECKING, Union, cast, dataclass_transform
@@ -109,16 +109,18 @@ def _check_if_ns_member(cls: type) -> Callable[[str], bool]:
         return lambda x: member_type == anno_dict.get(x)
 
 
-def _ns_from_iter[
-    _KT, _VT
-](__iter: Iterator[_KT] | Callable[[], Iterator[_KT]], member_type: _VT = null) -> Callable[
-    [type[DynamicNamespace[_VT]]], type[DynamicNamespace[_VT]]
-]:
+def _ns_from_iter[_KT, _VT](
+    __iter: Iterator[_KT] | Callable[[], Iterator[_KT]], member_type: type[_VT] = object
+) -> Callable[[type[DynamicNamespace[_VT]]], type[DynamicNamespace[_VT]]]:
     def decorator(cls: type[DynamicNamespace[_VT]]):
         anno = cls.__annotations__
         type_params = cls.__type_params__
         m_iter = __iter() if callable(__iter) else iter(__iter)
-        members: Iterator[_KT] = m_iter if member_type == null else map(member_type, m_iter)
+        members: Iterator[_KT] = (
+            m_iter
+            if (member_type is object or not isinstance(member_type, type))
+            else map(member_type, m_iter)
+        )
         d = dict(zip((k for k, v in anno.items() if v in type_params), members))
         cls.__init__ = update_wrapper(
             lambda *args, **kwargs: cls.__base__.__init__(*args, **(kwargs | d)), cls.__init__
@@ -430,73 +432,73 @@ class _color_ns_getter:
             ) from None
 
 
-_dummy_func = lambda *args, **kwargs: ...
-_dummy_signature = signature(_dummy_func)
-
-
-class rgb_dispatch[**P, R]:  # noqa
-    color_ns = cast(MappingProxyType[str, Int3Tuple], _color_ns_getter())
-
-    __signature__ = _dummy_signature
+def rgb_dispatch[**P, R](
+    __f: Callable[P, R] = None, /, *, var_names: Sequence[str] = ()
+) -> Callable[P, R]:
+    dummy_func = lambda *args, **kwargs: ...
+    [rgb_args, variadic] = [set[str]() for _ in range(2)]
 
-    def __init__(self, __f: Callable[P, R] = None, /, *, args: Sequence[str] = ()):
-        if isinstance(args, str):
-            args = (args,)
+    def fix_signature():
+        nonlocal var_names, rgb_args, variadic
+        if isinstance(var_names, str):
+            var_names = (var_names,)
         if not callable(__f):
             raise ValueError
-        self._func = __f
         try:
-            argspec = getfullargspec(self._func)
-            sig = signature(self._func)
+            argspec = getfullargspec(__f)
+            sig = signature(__f)
         except TypeError:
-            if not (isbuiltin(self._func) or getattr(self._func, '__module__', '') == 'builtins'):
+            if not (isbuiltin(__f) or getattr(__f, '__module__', '') == 'builtins'):
                 raise
-            argspec = getfullargspec(_dummy_func)
-            sig = self.__signature__
-        self._variadic = {argspec.varargs, argspec.varkw}
-        self._variadic.discard(None)
-        all_args = self._variadic.union(argspec.args + argspec.kwonlyargs)
-        self._rgb_args = all_args.intersection(
-            {'*': argspec.varargs, '**': argspec.varkw}.get(arg) or arg for arg in args
+            argspec = getfullargspec(dummy_func)
+            sig = signature(dummy_func)
+        variadic = {argspec.varargs, argspec.varkw}
+        variadic.discard(None)
+        all_args = variadic.union(argspec.args + argspec.kwonlyargs)
+        rgb_args = all_args.intersection(
+            {'*': argspec.varargs, '**': argspec.varkw}.get(arg) or arg for arg in var_names
         )
-        if not self._rgb_args:
+        if not rgb_args:
             keys = frozenset({'fg', 'bg'})
             for arg in all_args:
                 if (arg[:2] in keys) or (arg[-2:] in keys):
-                    self._rgb_args.add(arg)
-        self._variadic &= self._rgb_args
+                    rgb_args.add(arg)
+        variadic &= rgb_args
         parameters = []
         for name, param in sig.parameters.items():
-            if name not in self._rgb_args or param.annotation is param.empty:
+            if name not in rgb_args or param.annotation is param.empty:
                 parameters.append(param)
             else:
                 anno = param.annotation
                 parameters.append(
                     param.replace(
                         annotation=str
-                        | eval(getattr(anno, '__name__', str(anno)), getmodule(self._func).__dict__)
+                        | eval(getattr(anno, '__name__', str(anno)), getmodule(__f).__dict__)
                     )
                 )
-        self.__signature__ = sig.replace(parameters=parameters)
-        update_wrapper(self, self._func)
+        return sig.replace(parameters=parameters)
+
+    __f.__signature__ = fix_signature()
+    color_ns = cast(MappingProxyType[str, Int3Tuple], _color_ns_getter())
 
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
-        bound = self.__signature__.bind(*args, **kwargs)
+    @wraps(__f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        bound = getattr(__f, '__signature__').bind(*args, **kwargs)
         bound.apply_defaults()
         for arg, value in bound.arguments.items():
-            if arg not in self._rgb_args:
+            if arg not in rgb_args:
                 continue
-            if arg in self._variadic:
+            if arg in variadic:
                 bound.arguments[arg] = (
-                    tuple(self.color_ns[v] if v in self.color_ns else v for v in value)
+                    tuple(color_ns[v] if v in color_ns else v for v in value)
                     if isinstance(value, tuple)
-                    else {
-                        k: self.color_ns[v] if v in self.color_ns else v for k, v in value.items()
-                    }
+                    else {k: color_ns[v] if v in color_ns else v for k, v in value.items()}
                 )
-            elif value in self.color_ns:
-                bound.arguments[arg] = self.color_ns[value]
-        return self._func(*bound.args, **bound.kwargs)
+            elif value in color_ns:
+                bound.arguments[arg] = color_ns[value]
+        return __f(*bound.args, **bound.kwargs)
+
+    return wrapper
 
 
 # fmt: off

chromatic/color/palette.pyi

@@ -1,9 +1,8 @@
 __all__ = ['Back', 'ColorNamespace', 'Fore', 'Style', 'rgb_dispatch', 'named_color']
 
-import inspect
 from collections.abc import Sequence
-from types import MappingProxyType
-from typing import Callable, Iterator, Literal, TypeAlias, TypeVar, Union, overload
+from types import FunctionType
+from typing import Callable, Iterator, Literal, TypeAlias, TypeVar, Union
 
 from .core import Color, ColorStr, color_chain
 from .._typing import Int3Tuple
@@ -298,17 +297,7 @@ named_color: Union[
     dict[Literal['24b'], Callable[[_ColorName], Color]],
 ]
 
-class rgb_dispatch[**P, R]:
-    color_ns: MappingProxyType[str, Int3Tuple]
-
-    __signature__: inspect.Signature
-
-    @overload
-    def __new__(cls, __f: Callable[P, R], /, *, args: Sequence[str] = ()):
-        return __f
-
-    @property
-    def __wrapped__(self) -> Callable[P, R]: ...
+def rgb_dispatch[F: (type, FunctionType)](__f: F, /, *, var_names: Sequence[str] = ()) -> F: ...
 
 Back = AnsiBack()
 Fore = AnsiFore()

chromatic/data/__init__.py

@@ -36,12 +36,8 @@ def _build_config():
     f: SupportsWrite
     d: dict[Literal['fonts', 'images'] | Literal['__hash__'], dict[str, str] | str]
     d = {'fonts': {}, 'images': {}, '__hash__': ''}
-    printable = ''.join(
-        c for c in printable if any((c.isalnum(), c.isidentifier(), c == '.'))
-    )
-    for font_fp in (
-        (Path(fonts) / x).absolute() for x in filter(_is_ttf_ext, os.listdir(fonts))
-    ):
+    printable = ''.join(c for c in printable if any((c.isalnum(), c.isidentifier(), c == '.')))
+    for font_fp in ((Path(fonts) / x).absolute() for x in filter(_is_ttf_ext, os.listdir(fonts))):
         font_name = font_fp.stem
         for c in set(font_name):
             if c not in printable:
@@ -71,9 +67,7 @@ def _validate(**kwargs):
         s1, s2 = (
             set(
                 str(fp.relative_to(data_root))
-                for fp in (
-                    (Path(subdir) / x).absolute() for x in filter(f, os.listdir(subdir))
-                )
+                for fp in ((Path(subdir) / x).absolute() for x in filter(f, os.listdir(subdir)))
             )
             for f, subdir in zip((_is_ttf_ext, _is_img_ext), (fonts, images))
         )
@@ -119,9 +113,7 @@ def _create_font_enum() -> type['UserFont']:
     def path(self):
         return data_root / Path(_font_data_[self.name])
 
-    enum_cls = IntEnum(
-        'UserFont', {k: i for (i, k) in enumerate(sorted(_font_data_.keys()))}
-    )
+    enum_cls = IntEnum('UserFont', {k: i for (i, k) in enumerate(sorted(_font_data_.keys()))})
     enum_cls.path = property(path)
     return enum_cls
 
@@ -156,9 +148,7 @@ def register_user_font[AnyStr: (str, bytes)](__path: AnyStr | os.PathLike[AnyStr
     if path_obj.is_symlink():
         path_obj = path_obj.readlink()
     if path_obj.suffix != '.ttf':
-        raise ValueError(
-            f"Expected '.ttf' file, " f"got filetype {path_obj.suffix!r} instead"
-        )
+        raise ValueError(f"Expected '.ttf' file, " f"got filetype {path_obj.suffix!r} instead")
     from PIL.ImageFont import FreeTypeFont
 
     try:

chromatic/demo.py

@@ -143,7 +143,7 @@ def named_colors():
         )
         buffer.append(xs)
     for ln in buffer:
-        print(' | '.join(ln))
+        print(' | '.join(map(str, ln)))
 
 
 def color_table():
@@ -174,12 +174,12 @@ def color_table():
         for c in colors
     ]
     bg_colors = [ColorStr().recolor(bg=None)] + [c.recolor(fg=None, bg=c.fg) for c in fg_colors]
-    pad = spacing - 1
-    print('|'.join([f"{'4bit': ^{pad}}", f"{'8bit': ^{pad}}", f"{'24bit': >{pad}}"]))
+    print('|'.join(f"{'%dbit' % n: {'>' if n > 9 else '^'}{spacing - 1}}" for n in (4, 8, 24)))
+    suffix = '\x1b[0m' if sys.stdout.isatty() else ''
     for row in fg_colors:
         for col in bg_colors:
             for typ in ansi_types:
-                print(row.as_ansi_type(typ).recolor(bg=col.bg), end='\x1b[0m')
+                print(row.as_ansi_type(typ).recolor(bg=col.bg), end=suffix)
         print()
     print('\nstyles:')
     print()
@@ -195,7 +195,7 @@ def color_table():
     for style in style_params:
         print(
             ColorStr('.'.join([SgrParameter.__qualname__, style.name])).update_sgr(style),
-            end='\x1b[0m' + (' ' * 4),
+            end=suffix + (' ' * 4),
         )
     print()
 

{chromatic_python-0.2.1.dist-info → chromatic_python-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chromatic-python
-Version: 0.2.1
+Version: 0.2.2
 Summary: ANSI art image processing and colored terminal text
 Author: crypt0lith
 License: MIT License
@@ -27,20 +27,21 @@ 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
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fonttools~=4.51.0
 Requires-Dist: networkx~=3.4.2
-Requires-Dist: numpy~=2.1.1
-Requires-Dist: opencv-python~=4.10.0.84
-Requires-Dist: pillow~=10.4.0
-Requires-Dist: scikit-image~=0.25.0rc1
-Requires-Dist: scikit-learn~=1.5.2
-Requires-Dist: scipy~=1.14.1
+Requires-Dist: numpy~=2.2.6
+Requires-Dist: pillow~=11.2.1
+Requires-Dist: opencv-python~=4.11.0.86
+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
 Dynamic: license-file
 
 ![image](/logo/logo.PNG)

{chromatic_python-0.2.1.dist-info → chromatic_python-0.2.2.dist-info}/RECORD

@@ -1,19 +1,19 @@
-chromatic/__init__.py,sha256=kDmPuhakyiB85eBKsRcu67p1XD--9ZY4uiWI_3QfvPs,792
-chromatic/_typing.py,sha256=vcdS3dYwZPhpA6wWg3MDSiO2OhyaToRjfHYoBez3R5Q,14711
-chromatic/_version.py,sha256=cTPlZaUCc20I4ZWsDjY35UftpFNRgfDaDBgkWxfIQmg,532
-chromatic/demo.py,sha256=gz2wpXZv01YVF-xF8EA3YK6LnCPSXiYGKtTwmVB7SKQ,12698
+chromatic/__init__.py,sha256=qDsFcpBycwOTojKMKlpyfkj0pj3wUFDswZtxP2EDSzg,3309
+chromatic/_typing.py,sha256=aPdYI3nFpkGArErzZzv73Rf-Bur3WOsaRyfy8CbWRtE,14714
+chromatic/_version.py,sha256=UC90NvqLUDpj_FE8q0wCmEOBTFqTc2wo52DnLF1e7lU,532
+chromatic/demo.py,sha256=WmtHsJ96MvepLwXBIo8XVcalgAw5P5nlb_TZLRN45qE,12744
 chromatic/ascii/__init__.py,sha256=Ic3bqfqr0uAJd6vB4kToDookvZVr8Nrkyy3speiH5oM,164
-chromatic/ascii/_array.py,sha256=P7PINIQJ7ZAJKKQbgn8i7lgm8NEOK9W89MAb81dZE-s,38286
+chromatic/ascii/_array.py,sha256=ZLNU1x1Jabz9b9Tky6eKKLQyM5gt3tBrks7eegIbtu8,39270
 chromatic/ascii/_curses.py,sha256=Mz-_FgFUvACjMZyFoy1LXpxJzg5ekcyjMV8fYHXHcpA,3632
 chromatic/ascii/_glyph_proc.py,sha256=VVRMFRu4oT7iH-q1MMgmZAnuQ0hbSrmtqtt9q3JnOLQ,2865
 chromatic/color/__init__.py,sha256=8dnpWqbmEciFgJrQpUC0gV9M5D1bKIF7d9Sl4mj0x7g,185
 chromatic/color/colorconv.py,sha256=2FygfpgNX6pfo47DhXNqwA46Nnpw8TbmCD1ThuIdZn4,8400
-chromatic/color/core.py,sha256=mynDpSLMvz93UW_OjMyj3wKU_4wsc5zC_kfPsa4q7MQ,59657
-chromatic/color/core.pyi,sha256=E1EMxhR7g7ICdOypRptBefE8Cx2Wslo6-xYeTPtM0no,12011
+chromatic/color/core.py,sha256=vTAHdUY4oZBAgQIz0vaisapasLJab9lVE1emr6FWF8c,59732
+chromatic/color/core.pyi,sha256=nQnfzmA7bPY9rSr7EC9tXrJ_R4NST9VD_6yqZTBxixU,12045
 chromatic/color/iterators.py,sha256=v-JirP7ZvcDzsccD5Cctwsnu3qndCjOolGliAqN0azU,6099
-chromatic/color/palette.py,sha256=WuJLfQJPSGkzs7708AS-cybtUzYzdMYWwZM9eM5PmsI,18817
-chromatic/color/palette.pyi,sha256=1_4rpw4rGSbZjdEwSMVDeu6bK6Y5ym0_2-gCYwM7p8w,10481
-chromatic/data/__init__.py,sha256=IVfKnpn5iKSk9GYIm3uhdE5810dVla36H0bboeYXTcw,6650
+chromatic/color/palette.py,sha256=Fz_mC7IUeI3-YF23aJPpF5RKVLOsQgWe17Lfq5uGplo,18802
+chromatic/color/palette.pyi,sha256=Umdp_Ichm3-avs-bkwv3Nwb9lyquFOdEtlAhwuqrMGE,10252
+chromatic/data/__init__.py,sha256=6-nmWy2dSlXblkwbtAmsg55HXmVnAGBSOJYb0j7j098,6538
 chromatic/data/__init__.pyi,sha256=AZGa46n1Hck3xHN91Mmm7Qibg--CYweKJMMFPHH6yY8,556
 chromatic/data/fonts/IBM_VGA_437_8x16.ttf,sha256=qMdn-pJWJNKNmHnDoDqGIE94vOTezaCiBv0VK92QbJQ,50124
 chromatic/data/fonts/consolas.ttf,sha256=xubOgRn91H7GpUSaCOLSrX9B6gMUOq4ZMGjtn6WOrrw,459180
@@ -21,8 +21,8 @@ chromatic/data/images/butterfly.jpg,sha256=rnSfMVotSgpTNRPQ9CzYpDp8S8lkCAJ5ZySRr
 chromatic/data/images/escher.png,sha256=FvAC-WOkUVIqHBxasfgCJbH1CN1IwLE-JyMiATOEKFc,132667
 chromatic/data/images/goblin_virus.png,sha256=ygs19t4ZeZYsbiRFXjRyEz8OtgC9Zyl8owX0O-5n40o,8849
 chromatic/data/images/hotdog.jpg,sha256=b0vnoQCarhq-gFu3df512qPTvauvF1Oa0oXVO9msEFc,60823
-chromatic_python-0.2.1.dist-info/licenses/LICENSE,sha256=e7GjzmO7L12JDai3XRWHD8PgZvFmzNceEztB6d-9kuA,1086
-chromatic_python-0.2.1.dist-info/METADATA,sha256=Ao57WdhTMs-9FEqHHJHcErYQJP_jxlvd0aG9hijCAaA,5993
-chromatic_python-0.2.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-chromatic_python-0.2.1.dist-info/top_level.txt,sha256=wjzxcxfjO8I4u22BS8wL67Bq64c59kbZCqQ--Fc_Mqw,10
-chromatic_python-0.2.1.dist-info/RECORD,,
+chromatic_python-0.2.2.dist-info/licenses/LICENSE,sha256=e7GjzmO7L12JDai3XRWHD8PgZvFmzNceEztB6d-9kuA,1086
+chromatic_python-0.2.2.dist-info/METADATA,sha256=2AVOeLAWh5W6zhoSx8d6_KHqPFdc3hypl_8Kjzbcg8M,6042
+chromatic_python-0.2.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+chromatic_python-0.2.2.dist-info/top_level.txt,sha256=wjzxcxfjO8I4u22BS8wL67Bq64c59kbZCqQ--Fc_Mqw,10
+chromatic_python-0.2.2.dist-info/RECORD,,

{chromatic_python-0.2.1.dist-info → chromatic_python-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any