chromatic-python 0.4.1__py3-none-any.whl → 0.4.2__py3-none-any.whl

chromatic/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.1'
-__version_tuple__ = version_tuple = (0, 4, 1)
+__version__ = version = '0.4.2'
+__version_tuple__ = version_tuple = (0, 4, 2)
 
 __commit_id__ = commit_id = None

chromatic/color/core.py

@@ -280,15 +280,22 @@ class ansicolor4Bit(colorbytes):
     """ANSI 4-bit color format.
 
     Supports 16 colors:
-        * 8 standard colors:
-            {0: black, 1: red, 2: green, 3: yellow, 4: blue, 5: magenta, 6: cyan, 7: white}
-        * 8 bright colors, each mapping to a standard color (bright = standard + 8).
+
+    * 8 standard colors:
+        {0: black, 1: red, 2: green, 3: yellow, 4: blue, 5: magenta, 6: cyan, 7: white}
+
+    * 8 bright colors, each mapping to a standard color (bright = standard + 8).
 
     Color codes use escape sequences of the form:
-        * `CSI 30–37 m` for standard foreground colors.
-        * `CSI 40–47 m` for standard background colors.
-        * `CSI 90–97 m` for bright foreground colors.
-        * `CSI 100–107 m` for bright background colors.
+
+    * `CSI 30–37 m` for standard foreground colors.
+
+    * `CSI 40–47 m` for standard background colors.
+
+    * `CSI 90–97 m` for bright foreground colors.
+
+    * `CSI 100–107 m` for bright background colors.
+
     Where `CSI` (Control Sequence Introducer) is `ESC[`.
 
     Examples
@@ -310,13 +317,19 @@ class ansicolor8Bit(colorbytes):
     """ANSI 8-Bit color format.
 
     Supports 256 colors, mapped to the following value ranges:
-        * (0, 15): Corresponds to ANSI 4-bit colors.
-        * (16, 231): Represents a 6x6x6 RGB color cube.
-        * (232, 255): Greyscale colors, from black to white.
+
+    * (0, 15): Corresponds to ANSI 4-bit colors.
+
+    * (16, 231): Represents a 6x6x6 RGB color cube.
+
+    * (232, 255): Greyscale colors, from black to white.
 
     Color codes use escape sequences of the form:
-        * `CSI 38;5;(n) m` for foreground colors.
-        * `CSI 48;5;(n) m` for background colors.
+
+    * `CSI 38;5;(n) m` for foreground colors.
+
+    * `CSI 48;5;(n) m` for background colors.
+
     Where `CSI` (Control Sequence Introducer) is `ESC[` and `n` is an unsigned 8-bit integer.
 
     Examples
@@ -340,8 +353,11 @@ class ansicolor24Bit(colorbytes):
     Supports all colors in the RGB color space (16,777,216 total).
 
     Color codes use escape sequences of the form:
-        * `CSI 38;2;(r);(g);(b) m` for foreground colors.
-        * `CSI 48;2;(r);(g);(b) m` for background colors.
+
+    * `CSI 38;2;(r);(g);(b) m` for foreground colors.
+
+    * `CSI 48;2;(r);(g);(b) m` for background colors.
+
     Where `CSI` (Control Sequence Introducer) is `ESC[` and `r,g,b` are unsigned 8-bit integers.
 
     Examples
@@ -523,10 +539,11 @@ def rgb2ansi_escape(fmt, mode, rgb):
 class Color(int):
     """
     Color([x]) -> color
+
     Color(x, base=10) -> color
 
-        Convert a number or string into a color, or return Color(0) if no arguments are given.
-        Accepts the same arguments as int, but the value must be in range 0,0xFFFFFF (incl).
+    Convert a number or string into a color, or return Color(0) if no arguments are given.
+    Accepts the same arguments as int, but the value must be in range 0,0xFFFFFF (incl).
     """
 
     def __new__(cls, *args, **kwargs):
@@ -553,7 +570,7 @@ class Color(int):
 
 
 def randcolor():
-    """Return a random color as a Color object."""
+    """Return a random color as a `Color` object"""
     return Color.from_bytes(random.randbytes(3))
 
 
@@ -620,7 +637,9 @@ class SgrParamBuffer[_T]:
 def _get_sgr_nums(__x: bytes) -> list[int]:
     """Return a list of integers from a bytestring of ANSI SGR parameters.
 
-    Roughly, bitwise equivalent to `list(map(int, bytes().split(b';')))`.
+    Roughly, bitwise equivalent to:
+
+        list(map(int, bytes().split(b';')))
     """
     if __x.isdigit():
         return [int(__x)]
@@ -654,10 +673,9 @@ def _get_sgr_nums(__x: bytes) -> list[int]:
             return res
 
 
-def _iter_normalized_sgr[_T: (
-    Buffer,
-    SupportsInt,
-)](__iter: bytes | bytearray | Iterable[_T]) -> Iterator[int | AnsiColorFormat]:
+def _iter_normalized_sgr[_T: (Buffer, SupportsInt)](
+    __iter: bytes | bytearray | Iterable[_T],
+) -> Iterator[int | AnsiColorFormat]:
     if _issubclass(type(__iter), (bytes, bytearray)):
         __iter = __iter.split(b';')
     elt: object | Any
@@ -1019,9 +1037,10 @@ def _colorstr[_T](
 
 
 class _IntFloatMixin:
-    """Mixin for ColorStr -> int/float conversion
+    """Mixin for `ColorStr` -> `int`/`float` conversion
 
-    Notes:
+    Notes
+    -----
         If supplying 'base' to `int`, CPython ignores `nb_int` due to `PyUnicode_Check`.
         Use `ColorStr.base_str` directly in that case.
     """
@@ -1084,12 +1103,13 @@ class ColorStr(str, _IntFloatMixin):
 
     def recolor(self, *args, **kwargs):
         """ColorStr.recolor(self, __value, *, absolute=False) -> ColorStr
+
         ColorStr.recolor(self, *, fg=None, bg=None, absolute=False) -> ColorStr
 
         Return a copy of self with a new color spec.
 
         If no arguments are given, returns self unchanged.
-        If __value is given and a ColorStr, return self with the colors of __value.
+        If __value is given and a `ColorStr`, return self with the colors of __value.
         Else, use keyword arguments { 'fg', 'bg' } for colors.
         Any other mix of arguments will fail outright,
         since __value along with { fg=... | bg=... } is ambiguous which to use for colors.
@@ -1575,7 +1595,7 @@ def _collect_masks(
     return masks
 
 
-class color_chain:
+class color_chain(Sequence[tuple[SgrSequence, str]]):
     @staticmethod
     def _is_mask_seq(obj):
         if isinstance(obj, Sequence):
@@ -1615,6 +1635,7 @@ class color_chain:
         raise TypeError
 
     def shrink(self):
+        """Return a copy where SGR sequences are joined for spans of empty string parts"""
         if self:
             maxlen = len(self._masks)
             it = enumerate(self._masks)
@@ -1622,9 +1643,10 @@ class color_chain:
             while True:
                 try:
                     idx, (sgr, s) = next(it)
+                    sgr = sgr.copy()
                     while idx + 1 < maxlen and not s:
                         idx, xs = next(it)
-                        sgr += xs[0]; s = xs[1]    # fmt: skip
+                        sgr += xs[0]; s = xs[1]  # fmt: skip
                     else:
                         out.append((sgr, s))
                 except StopIteration:
@@ -1633,6 +1655,18 @@ class color_chain:
             out = self.masks
         return self._from_masks_unchecked(out, ansi_type=self._ansi_type)
 
+    def merge(self, *other):
+        if not other:
+            return self
+        masks = self.masks
+        for x in other:
+            for sgr, s in x:
+                if not masks[-1][-1]:
+                    masks[-1] = masks[-1][0] + sgr, s
+                else:
+                    masks.append((sgr, s))
+        return self._from_masks_unchecked(masks, ansi_type=self._ansi_type)
+
     def __add__(self, other):
         try:
             masks = _collect_masks(
@@ -1665,6 +1699,11 @@ class color_chain:
     def __len__(self):
         return len(self._masks)
 
+    def __or__(self, other):
+        if _issubclass(other.__class__, self.__class__):
+            return self.merge(other)
+        return NotImplemented
+
     def __radd__(self, other):
         if isinstance(other, ColorStr):
             return self._from_masks_unchecked(
@@ -1685,8 +1724,8 @@ class color_chain:
         return NotImplemented
 
     def __repr__(self):
-        return "{.__name__}({})".format(
-            type(self),
+        return "{.__class__.__name__}({})".format(
+            self,
             ', '.join(
                 [
                     repr([f"{sgr}{s}" for sgr, s in self._masks]),

chromatic/color/core.pyi

@@ -93,10 +93,7 @@ class Color(int):
 class colorbytes(bytes):
     @classmethod
     @overload
-    def from_rgb[_T, _VT: (
-        SupportsInt,
-        RGBVectorLike,
-    )](
+    def from_rgb[_T, _VT: (SupportsInt, RGBVectorLike)](
         cls: type[_T],
         __rgb: (
             tuple[ColorDictKeys, _VT] | Mapping[L['fg'], _VT] | Mapping[L['bg'], _VT]
@@ -104,16 +101,13 @@ class colorbytes(bytes):
     ) -> _T: ...
     @classmethod
     @overload
-    def from_rgb[_T, _VT: (
-        SupportsInt,
-        RGBVectorLike,
-    )](cls: type[_T], __rgb: tuple[str, _VT] | Mapping[str, _VT]) -> _T: ...
+    def from_rgb[_T, _VT: (SupportsInt, RGBVectorLike)](
+        cls: type[_T], __rgb: tuple[str, _VT] | Mapping[str, _VT]
+    ) -> _T: ...
     @overload
-    def __new__[_T: (
-        ansicolor4Bit,
-        ansicolor8Bit,
-        ansicolor24Bit,
-    )](cls: AnsiColorType, __ansi: bytes | AnsiColorFormat) -> Self: ...
+    def __new__[_T: (ansicolor4Bit, ansicolor8Bit, ansicolor24Bit)](
+        cls: AnsiColorType, __ansi: bytes | AnsiColorFormat
+    ) -> Self: ...
     @overload
     def __new__(cls, __ansi: bytes | _AnsiColor_co) -> AnsiColorFormat: ...
     def to_param_buffer(self) -> SgrParamBuffer[Self]: ...
@@ -279,7 +273,7 @@ class _ColorChainKwargs(TypedDict, total=False):
     fg: Color | int | Int3Tuple
     bg: Color | int | Int3Tuple
 
-class color_chain:
+class color_chain(Sequence[tuple[SgrSequence, str]]):
     @staticmethod
     def _is_mask_seq(obj: object) -> TypeGuard[Sequence[tuple[SgrSequence, str]]]: ...
     @classmethod
@@ -293,12 +287,10 @@ class color_chain:
         ansi_type: type[AnsiColorFormat] = None,
     ) -> Self: ...
     def shrink(self) -> Self: ...
-    def __add__[_T: (
-        color_chain,
-        SgrSequence,
-        ColorStr,
-        str,
-    )](self, other: _T) -> color_chain: ...
+    def merge(self, *other: Iterable[tuple[SgrSequence, str]]) -> Self: ...
+    def __add__[_T: (color_chain, SgrSequence, ColorStr, str)](
+        self, other: _T
+    ) -> color_chain: ...
     def __bool__(self) -> bool: ...
     def __call__(self, __obj=None) -> str: ...
     @overload
@@ -309,12 +301,10 @@ class color_chain:
         self, __sgr: Iterable[_T] = ..., *, ansi_type: AnsiColorParam = ...
     ) -> None: ...
     def __len__(self) -> int: ...
-    def __radd__[_T: (
-        color_chain,
-        ColorStr,
-        str,
-        SgrSequence,
-    )](self, other: _T) -> color_chain: ...
+    def __or__(self, other: color_chain) -> Self: ...
+    def __radd__[_T: (color_chain, ColorStr, str, SgrSequence)](
+        self, other: _T
+    ) -> color_chain: ...
 
     _ansi_type: type[AnsiColorFormat] | None
     _masks: list[tuple[SgrSequence, str]]
@@ -416,13 +406,11 @@ class SgrParamBuffer[
     @property
     def value(self) -> _T: ...
     __slots__ = ('_bytes', '_is_color', '_is_reset', '_value')
-    # _value: _T
 
 class SgrSequence(MutableSequence[SgrParamBuffer]):
     def _update_colors(self): ...
     def is_color(self) -> bool: ...
     def is_reset(self) -> bool: ...
-    def has_bright_colors(self) -> bool: ...
     def values(self) -> Iterator[bytes | AnsiColorFormat]: ...
     def copy(self) -> Self: ...
     def insert(self, __index: SupportsIndex, __value: bytes | SgrParamBuffer): ...
@@ -455,11 +443,9 @@ class SgrSequence(MutableSequence[SgrParamBuffer]):
     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'

chromatic/data/__init__.py

@@ -1,5 +1,7 @@
 __all__ = [
+    'DEFAULT_FONT',
     'UserFont',
+    'VGA437',
     'butterfly',
     'escher',
     'goblin_virus',
@@ -14,7 +16,7 @@ if "CHROMATIC_DATADIR" not in os.environ:
     os.environ["CHROMATIC_DATADIR"] = osp.dirname(__file__)
 
 from ._fetchers import _load
-from .userfont import userfont, register_userfont, UserFont
+from .userfont import userfont, register_userfont, UserFont, VGA437, DEFAULT_FONT
 
 
 def __dir__():

chromatic/data/__init__.pyi

@@ -1,5 +1,7 @@
 __all__ = [
+    'DEFAULT_FONT',
     'UserFont',
+    'VGA437',
     'butterfly',
     'escher',
     'goblin_virus',
@@ -9,7 +11,7 @@ __all__ = [
 
 import PIL.Image
 
-from .userfont import userfont, register_userfont, UserFont
+from .userfont import DEFAULT_FONT, UserFont, VGA437, register_userfont, userfont
 
 def butterfly() -> PIL.Image.ImageFile.ImageFile: ...
 def escher() -> PIL.Image.ImageFile.ImageFile: ...

chromatic/data/userfont.py

@@ -1,7 +1,7 @@
 import json
 import os
 import os.path as osp
-from dataclasses import field, dataclass, MISSING, fields
+from dataclasses import dataclass, field
 from types import MappingProxyType
 from typing import AnyStr, TYPE_CHECKING
 
@@ -38,21 +38,6 @@ class UserFont:
             osp.join(os.environ["CHROMATIC_DATADIR"], self.font), strict=True
         )
 
-    def __repr__(self):
-        cls = type(self)
-        inst_fields = {}
-        for f in fields(cls):  # noqa
-            v = getattr(self, f.name)
-            if f.default is MISSING or v != f.default:
-                inst_fields[f.name] = v
-        try:
-            inst_fields["font"] = os.fspath(self)
-        except (OSError, FileNotFoundError):
-            pass
-        return f"{cls.__name__}(%s)" % ', '.join(
-            f"{k}={v!r}" for k, v in inst_fields.items()
-        )
-
     def to_truetype(self):
         from PIL.ImageFont import truetype
 
@@ -151,3 +136,4 @@ def _init_userfonts():
 
 
 _init_userfonts()
+DEFAULT_FONT = VGA437 = userfont['vga437']

chromatic/data/userfont.pyi

@@ -1,5 +1,5 @@
 from os import PathLike
-from typing import AnyStr
+from typing import AnyStr, Final
 from types import MappingProxyType
 
 from PIL.ImageFont import FreeTypeFont
@@ -17,6 +17,8 @@ class UserFont:
     def to_truetype(self) -> FreeTypeFont: ...
 
 userfont: MappingProxyType[str, UserFont]
+VGA437: Final[UserFont] = userfont['vga437']
+DEFAULT_FONT = VGA437
 
 def register_userfont(
     fp: AnyStr | PathLike[AnyStr],

chromatic/image/_array.py

@@ -56,7 +56,7 @@ from ..color.core import (
     sgr_pattern,
 )
 from ..color.palette import rgb_dispatch
-from ..data import UserFont, userfont
+from ..data import UserFont, userfont, VGA437
 
 if TYPE_CHECKING:
     from _typeshed import SupportsRead
@@ -509,7 +509,7 @@ def img2ascii(
 
 def img2ascii(
     __img: RGBImageLike | PathLike[str] | str,
-    __font: FontArgType = userfont['vga437'],
+    __font: FontArgType = VGA437,
     factor: int = 200,
     char_set: Iterable[str] = None,
     sort_glyphs: bool | type[reversed] = True,
@@ -566,9 +566,7 @@ def img2ascii(
     if char_set is None:
         from ._curses import ascii_printable, cp437_printable
 
-        chars_getter = dict.get(
-            {userfont['vga437']: cp437_printable}, __font, ascii_printable
-        )
+        chars_getter = dict.get({VGA437: cp437_printable}, __font, ascii_printable)
         char_set = shuffle_char_set(chars_getter())
     elif type(char_set) is not str:
         char_set = ''.join(char_set)
@@ -587,7 +585,7 @@ def img2ascii(
 @rgb_dispatch('bg')
 def img2ansi(
     __img: RGBImageLike | PathLike[str] | str,
-    __font: FontArgType = userfont['vga437'],
+    __font: FontArgType = VGA437,
     factor: int = 200,
     char_set: Iterable[str] = None,
     ansi_type: AnsiColorParam = DEFAULT_ANSI,
@@ -685,7 +683,7 @@ def img2ansi(
 @rgb_dispatch('fg', 'bg')
 def ascii2img(
     __s: str,
-    font: FontArgType = userfont['vga437'],
+    font: FontArgType = VGA437,
     font_size=16,
     *,
     fg: Int3Tuple | str = (0, 0, 0),
@@ -724,7 +722,7 @@ def ascii2img(
     n_rows, n_cols = map(len, (lines, lines[0]))
     cw, ch = _get_bbox_shape(font)
     iw, ih = (int(i * j) for i, j in zip((cw, ch), (n_cols, n_rows)))
-    (r, g, b) = tuple(map(int, bg))
+    r, g, b = tuple(map(int, bg))
     img = Image.new('RGB', (iw, ih), (r, g, b))
     draw = ImageDraw.Draw(img)
     y_offset = 0
@@ -737,7 +735,7 @@ def ascii2img(
 @rgb_dispatch('fg_default', 'bg_default')
 def ansi2img(
     __ansi_array: list[list[ColorStr]],
-    font: FontArgType = userfont['vga437'],
+    font: FontArgType = VGA437,
     font_size=16,
     *,
     fg_default: Int3Tuple | TupleOf4[int] | str = (170, 170, 170),
@@ -802,7 +800,7 @@ def ansi2img(
     else:
         conv = lambda x: x
         img = Image.new('RGB', (iw, ih), bg_default)
-        
+
     draw = ImageDraw.Draw(img)
     y_offset = 0
     for row in __ansi_array:
@@ -836,7 +834,7 @@ def ansi2img(
 
 def ansify(
     __img: RGBImageLike | PathLike[str] | str,
-    font: FontArgType = userfont['vga437'],
+    font: FontArgType = VGA437,
     font_size: int = 16,
     *,
     factor: int = 200,
@@ -903,59 +901,64 @@ def _is_csi_param(__c: str) -> TypeGuard[Literal[';'] | LiteralDigit]:
 def cursor_or_sgr_pattern():
     sgr_re = sgr_pattern().pattern.removeprefix(r'\x1b\[')
     return re.compile(
-        rf"(?:\x1b\[(?:(?P<cursor>\d*[A-G]|\d*(?:;\d*)?H)|(?P<sgr>{sgr_re})))?(?P<text>[^\x1b]*)"
+        r"(?:\x1b\[(?:(?P<cursor>\d*[A-G]|\d*(?:;\d*)?H)"
+        r"|(?P<carriage_return>\r)"
+        rf"|(?P<sgr>{sgr_re})))?(?P<text>[^\x1b]*)"
     )
 
 
-_compile = re.compile
-_compile = lru_cache(maxsize=1)(_compile)
-
 def _sub_bold_colors(lines: Iterable[str]) -> Iterator[str]:
     """Yield lines with bold foreground colors normalized to their ESC[9(n)m variants.
 
     Previous colors are also forwarded at each SGR position, if they are not overridden.
     """
     type TupleOf5[_T] = tuple[_T, _T, _T, _T, _T]
-    ansi_16c_fg_std = range(30, 38)
-    ansi_16c_fg_bold = range(90, 98)
 
     def sub(m: re.Match):
         nonlocal bold_bit, prev_colors
 
         params: list[Int3Tuple | TupleOf5[int] | int] = []
         nums = map(int, m[0].removeprefix('\x1b[').removesuffix('m').split(';'))
-        for i in nums:
-            if i in {38, 48}:
+        for n in nums:
+            if n in {38, 48}:
                 j = next(nums)
                 if j == 5:
-                    extended_param = (i, j, next(nums))
+                    extended_param = (n, j, next(nums))
                 elif j == 2:
-                    extended_param = (i, j, *(next(nums) for _ in range(3)))
+                    extended_param = (n, j, *(next(nums) for _ in range(3)))
                 else:
                     raise ValueError("invalid ansi color")
                 params.append(extended_param)
                 continue
-            elif i == 0:
+            elif n == 0:
                 bold_bit = False
                 prev_colors.clear()
-            elif i == 1:
+            elif n == 1:
                 bold_bit = True
-                for k, v in prev_colors.items():
-                    if len(v) == 1 and v[0] in ansi_16c_fg_std:
-                        prev_colors[k][0] += 60
-            elif i == 22:
+                for k, values in prev_colors.items():
+                    if k != 'fg':
+                        continue
+                    for idx, v in enumerate(values):
+                        if 30 <= v <= 38:
+                            prev_colors[k][idx] += 60
+                prev_colors.setdefault('fg', [97])
+            elif n == 22:
                 bold_bit = False
-                for k, v in prev_colors.items():
-                    if len(v) == 1 and v[0] in ansi_16c_fg_bold:
-                        prev_colors[k][0] -= 60
-            elif bold_bit and i in ansi_16c_fg_std:
-                i += 60
-            params.append(i)
+                for k, values in prev_colors.items():
+                    if k != 'fg':
+                        continue
+                    for idx, v in enumerate(values):
+                        if 90 <= v <= 98:
+                            prev_colors[k][idx] -= 60
+                prev_colors.setdefault('fg', [37])
+            elif bold_bit and 30 <= n <= 38:
+                n += 60
+            params.append(n)
         sgr = SgrSequence(
-            i
+            n
             for xs in [prev_colors.values(), params]
             for x in xs
-            for i in ([x] if isinstance(x, int) else x)
+            for n in ([x] if isinstance(x, int) else x)
         )
         for p in sgr:
             if p.is_color():
@@ -965,13 +968,32 @@ def _sub_bold_colors(lines: Iterable[str]) -> Iterator[str]:
                 )
         return f"{sgr}"
 
+    bold_bit = False
+    prev_colors: dict[str, list[int]] = {}
     for line in lines:
-        bold_bit = False
-        prev_colors = {}
         yield sgr_pattern().sub(sub, line)
 
 
-def reshape_ansi(__str: str, w: int, h: int) -> str:
+def _utf8_bytes(cp: int) -> Iterator[int]:
+    """yield the UTF-8 bytes of the ordinal value of a character"""
+
+    if cp <= 0x7F:
+        yield cp
+    elif cp <= 0x7FF:
+        yield 0b11000000 | (cp >> 6)
+        yield 0b10000000 | (cp & 0b00111111)
+    elif cp <= 0xFFFF:
+        yield 0b11100000 | (cp >> 12)
+        yield 0b10000000 | ((cp >> 6) & 0b00111111)
+        yield 0b10000000 | (cp & 0b00111111)
+    else:
+        yield 0b11110000 | (cp >> 18)
+        yield 0b10000000 | ((cp >> 12) & 0b00111111)
+        yield 0b10000000 | ((cp >> 6) & 0b00111111)
+        yield 0b10000000 | (cp & 0b00111111)
+
+
+def reshape_ansi(__s: str, w: int, h: int) -> str:
     def cursor() -> Generator[tuple[int, int], tuple[int, int], None]:
         idx, total = 0, h * w
         while idx < total:
@@ -981,87 +1003,101 @@ def reshape_ansi(__str: str, w: int, h: int) -> str:
             else:
                 idx += 1
 
-    def write_cell(content: str, *, incr=False):
-        nonlocal x, y
-        if content == '\n':
-            x = min(x + 1, h - 1)
-            y = 0
-            cur.send((x, y))
+    def write_cell(ch: str):
+        nonlocal y, x
+        if ch == '\n':
+            y = min(y + 1, h - 1)
+            x = 0
+            cur.send((y, x))
             return
-        elif arr[x][y] == '\x00':
-            arr[x][y] = content
         else:
-            arr[x][y] += content
-        if incr:
-            x, y = next(cur)
+            arr[y][x] = seq, ord(ch)
+        y, x = next(cur)
+
+    cursor_or_sgr_finditer = cursor_or_sgr_pattern().finditer
 
-    iter_matches = cursor_or_sgr_pattern().finditer
-    
-    arr = [['\x00'] * w for _ in range(h)]
+    arr: list[list[tuple[SgrSequence | None, int]]] = [
+        [(None, 0) for _ in range(w)] for _ in range(h)
+    ]
     cur = cursor()
-    x, y = next(cur)
-    for line in _sub_bold_colors(__str.splitlines()):
-        for m in iter_matches(line + '\n'):
-            if cg := m['cursor']:
-                write_cell(' ')
-                param, code = cg[:-1], cg[-1]
-                if code == 'H':
-                    if ';' in param:
-                        x, y = (int(i or 1) - 1 for i in param.partition(';')[::2])
+    seq = SgrSequence()
+    y, x = next(cur)
+    for line in _sub_bold_colors(__s.split('\n')):
+        try:
+            for m in cursor_or_sgr_finditer(line + '\n'):
+                if cg := m['cursor']:
+                    param, code = cg[:-1], cg[-1]
+                    if code == 'H':
+                        if ';' in param:
+                            y, x = (int(i or 1) - 1 for i in param.partition(';')[::2])
+                        else:
+                            y = int(param or 1) - 1
+                            x = 0
                     else:
-                        x = int(param or 1) - 1
-                        y = 0
-                else:
-                    n = int(param or 1)
-                    match code:
-                        case 'A':
-                            x = max(0, x - n)
-                        case 'B':
-                            x = min(h - 1, x + n)
-                        case 'C':
-                            y = min(w - 1, y + n)
-                        case 'D':
-                            y = max(0, y - n)
-                        case 'E':
-                            x += n
-                            y = 0
-                        case 'F':
-                            x -= n
-                            y = 0
-                        case 'G':
-                            y = n - 1
-                cur.send((x, y))
-            elif sgr := m['sgr']:
-                write_cell(f"\x1b[{sgr}")
-            for ch in m['text']:
-                write_cell(ch, incr=True)
-
-    any_ansi_seq = _compile(r"\x1b\[\d*(?:;\d*)*[A-HJ-KS-Tmf]")
-    ansi_ws_base = rf"(\s+)((?:{any_ansi_seq.pattern})+)(\s*)"
-    ansi_ws_prefix = _compile('^' + ansi_ws_base)
-    ansi_ws_suffix = _compile(ansi_ws_base + '$')
-    
-    out_lines = []
+                        n = int(param or 1)
+                        match code:
+                            case 'A':
+                                y = max(0, y - n)
+                            case 'B':
+                                y = min(h - 1, y + n)
+                            case 'C':
+                                x = min(w - 1, x + n)
+                            case 'D':
+                                x = max(0, x - n)
+                            case 'E':
+                                y += n
+                                x = 0
+                            case 'F':
+                                y -= n
+                                x = 0
+                            case 'G':
+                                x = n - 1
+                    cur.send((y, x))
+                elif m['carriage_return']:
+                    cur.send((y, 0))
+                elif m['sgr']:
+                    seq = SgrSequence(m['sgr'].encode().removesuffix(b'm'))
+                for c in m['text']:
+                    write_cell(c)
+        except StopIteration:
+            break
+
+    out = []
+    prev: SgrSequence | None = None
     for row in arr:
-        out_row = ''.join(cell.translate({0: ' '}) for cell in row)
-        lhs, rhs = map(' '.__mul__, divmod(w - len(any_ansi_seq.sub('', out_row)), 2))
-        line = f"{lhs}{out_row}{rhs}"
-        for pat in (ansi_ws_prefix, ansi_ws_suffix):
-            while m := pat.search(line):
-                line = ''.join([line[:m.start()], m[2], m[1], m[3], line[m.end():]])
-        out_lines.append(line)
-    return '\n'.join(out_lines)
+        if not row:
+            continue
+        buf = bytearray()
+        maxlen = len(row)
+        indices = enumerate(row)
+        while True:
+            try:
+                i, [sgr, b] = next(indices)
+                j = i + 1
+                if sgr and sgr != prev:
+                    buf.extend(bytes(sgr))
+                    prev = sgr
+                buf.extend(_utf8_bytes(b))
+                while j < maxlen and sgr == row[j][0]:
+                    j += 1
+                for _ in range(i + 1, j):
+                    _, [_, b] = next(indices)
+                    buf.extend(_utf8_bytes(b))
+            except StopIteration:
+                break
+        out.append(buf.decode())
+    return '\n'.join(out).translate({0: ' '})
 
 
 @lru_cache
-def to_sgr_array(__str: str, ansi_type: AnsiColorParam = None):
+def to_sgr_array(__s: str, ansi_type: AnsiColorParam = None):
     ansi_typ = DEFAULT_ANSI if ansi_type is None else get_ansi_type(ansi_type)
     new_cs = partial(ColorStr, ansi_type=ansi_typ, reset=False)
-    iter_matches = cursor_or_sgr_pattern().finditer
+    cursor_or_sgr_finditer = cursor_or_sgr_pattern().finditer
     xs = []
-    for line in _sub_bold_colors(__str.splitlines()):
+    for line in _sub_bold_colors(__s.split('\n')):
         x = []
-        for m in iter_matches(line):
+        for m in cursor_or_sgr_finditer(line):
             text = m["text"]
             if m["sgr"]:
                 sgr = SgrSequence(map(int, m["sgr"].removesuffix('m').split(';')))
@@ -1077,7 +1113,7 @@ def to_sgr_array(__str: str, ansi_type: AnsiColorParam = None):
 def render_ans(
     __s: str,
     shape: TupleOf2[int],
-    font: FontArgType = userfont['vga437'],
+    font: FontArgType = VGA437,
     font_size: int = 16,
     *,
     bg_default: Int3Tuple | TupleOf4[int] | str = (0, 0, 0),
@@ -1103,10 +1139,7 @@ def render_ans(
         'auto' will determine background color dynamically.
     """
     return ansi2img(
-        to_sgr_array(reshape_ansi(__s, *shape)),
-        font,
-        font_size,
-        bg_default=bg_default,
+        to_sgr_array(reshape_ansi(__s, *shape)), font, font_size, bg_default=bg_default
     )
 
 
@@ -1120,7 +1153,7 @@ def read_ans(__buf: SupportsRead[str] | TextIOWrapper[str]) -> str:
     content = __buf.read().translate({0: ' '})
     if ~(sauce_idx := content.rfind('\x1aSAUCE00')):
         content = content[:sauce_idx]
-    if hasattr(__buf, 'encoding') and __buf.encoding == 'cp437':
+    if getattr(__buf, 'encoding', None) == 'cp437':
         from ._curses import translate_cp437
 
         content = translate_cp437(content, ignore=(0x0A, 0x1A, 0x1B))
@@ -1130,14 +1163,11 @@ def read_ans(__buf: SupportsRead[str] | TextIOWrapper[str]) -> str:
 class AnsiImage:
 
     @classmethod
-    def open[AnyStr: (
-        str,
-        bytes,
-    )](
+    def open[AnyStr: (str, bytes)](
         cls,
         fp: int | PathLike[AnyStr] | AnyStr,
         shape: TupleOf2[int] = None,
-        encoding: str = 'cp437',
+        encoding: Optional[str] = 'cp437',
         ansi_type: AnsiColorParam = DEFAULT_ANSI,
     ) -> Self:
         """Construct an `AnsiImage` object from a text file.
@@ -1164,7 +1194,6 @@ class AnsiImage:
         inst._ansi_format = get_ansi_type(ansi_type)
         inst.file = open(fp, mode='r', encoding=encoding or None)
         if shape is None:
-            
             shape = get_terminal_size()
         inst._shape = shape
         return inst
@@ -1176,14 +1205,9 @@ class AnsiImage:
             raise ValueError("ambiguous value attribute")
         if attr_name == 'file':
             file: TextIOWrapper[str] = self.__dict__.pop(attr_name)
-            setattr(
-                self,
-                'data',
-                to_sgr_array(
-                    reshape_ansi(read_ans(file), *self.shape),
-                    ansi_type=self.ansi_format,
-                ),
-            )
+            s = reshape_ansi(read_ans(file), *self.shape)
+            arr = to_sgr_array(s, ansi_type=self.ansi_format)
+            setattr(self, 'data', arr)
             file.close()
         return self.data
 
@@ -1204,7 +1228,7 @@ class AnsiImage:
         return self._shape
 
     def render(
-        self, font: FontArgType = userfont['vga437'], font_size: int = 16, **kwargs
+        self, font: FontArgType = VGA437, font_size: int = 16, **kwargs
     ) -> ImageType:
         return ansi2img(self._getvalue(), font, font_size, **kwargs)
 
@@ -1278,12 +1302,10 @@ def scaled_hu_moments(arr: ShapedNDArray[TupleOf2[int], np.uint8]):
 
 
 def approx_gridlike(
-    fp: PathLike[str] | str,
-    font: FontArgType = userfont['vga437'],
-    shape: TupleOf2[int] = None,
+    fp: PathLike[str] | str, font: FontArgType = VGA437, shape: TupleOf2[int] = None
 ):
     from ._curses import cp437_printable
-    
+
     if shape is None:
         shape = get_terminal_size()
 

chromatic/image/_curses.py

@@ -69,17 +69,15 @@ CP437_TRANS_TABLE = MappingProxyType(
 
 
 @overload
-def translate_cp437[_T: (
-    int,
-    str,
-)](__x: str, *, ignore: _T | Iterable[_T] = ...) -> str: ...
+def translate_cp437[_T: (int, str)](
+    __x: str, *, ignore: _T | Iterable[_T] = ...
+) -> str: ...
 
 
 @overload
-def translate_cp437[_T: (
-    int,
-    str,
-)](__iter: Iterable[str], *, ignore: _T | Iterable[_T] = ...) -> Iterator[str]: ...
+def translate_cp437[_T: (int, str)](
+    __iter: Iterable[str], *, ignore: _T | Iterable[_T] = ...
+) -> Iterator[str]: ...
 
 
 def translate_cp437(

{chromatic_python-0.4.1.dist-info → chromatic_python-0.4.2.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: chromatic-python
-Version: 0.4.1
+Version: 0.4.2
 Summary: ANSI art image processing and colored terminal text
 Author: crypt0lith
-Project-URL: Homepage, https://github.com/crypt0lith/chromatic
+License-Expression: MIT
+Project-URL: repository, https://github.com/crypt0lith/chromatic.git
 Keywords: ansi,ascii,art,font,image,terminal,parser
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
@@ -11,7 +12,6 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: numpy<2.6,>=1.25.2
 Requires-Dist: pillow!=11.2.*,<12.0,>=10.1
 Requires-Dist: networkx<4.0,>=3.0
@@ -21,7 +21,6 @@ Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
 Requires-Dist: fonttools
 Requires-Dist: lazy_loader
-Dynamic: license-file
 
 ![image](https://raw.githubusercontent.com/crypt0lith/chromatic/master/banner.png)
 

{chromatic_python-0.4.1.dist-info → chromatic_python-0.4.2.dist-info}/RECORD

@@ -1,35 +1,34 @@
 chromatic/__init__.py,sha256=OMvWLvDuaYpXaku9n0yKa0TShBw-nmY_YuC5MsSxyK4,200
 chromatic/__init__.pyi,sha256=zSQbEqcA-pbjym13cxu5uNrDTKL5JXWQNfPfiWDJBnY,1691
 chromatic/_typing.py,sha256=mt_eVyzfG3pDhHPWqr9GIT9Re3NHtS9C0f5-UZsXz-U,15069
-chromatic/_version.py,sha256=k7cu0JKra64gmMNU_UfA5sw2eNc_GRvf3QmesiYAy8g,704
+chromatic/_version.py,sha256=A45grTqzrHuDn1CT9K5GVUbY4_Q3OSTcXAl3zdHzcEI,704
 chromatic/demo.py,sha256=py0qPkikRDcPELENlXJqulql1N4QN-Eg054Bl0g3py4,12653
 chromatic/color/__init__.py,sha256=t19DW9WMdd6FEN69vkckVRlsDPBHldulHv_JulwXxFc,99
 chromatic/color/__init__.pyi,sha256=QPR4ZywovtSNaiUGBWq5bStm5_NMDunviSa-3Cr71HA,1615
 chromatic/color/colorconv.py,sha256=UsST5ChrebQXmoVW4RXaAoyTREOnDd125w91JHeRwpE,8632
-chromatic/color/core.py,sha256=HhRWJ9ye_OkqnbdXVaisRQScooDTYPQIEy5TqkIu7mY,51989
-chromatic/color/core.pyi,sha256=HmoQiSXixVzRTgnUa1r5dKj06FNaGRG3Nmk6xJa-y_o,15699
+chromatic/color/core.py,sha256=MgBd8YvCam05wi91bYkwt8f1JoR06P76lbLGwUGdGn4,52672
+chromatic/color/core.pyi,sha256=jM818chQ1fPazCjeq93rBGC9zUe9AbsfeXhJvAbjPFw,15686
 chromatic/color/iterators.py,sha256=7lbqZFG7M09DvMwDogjsAUrfWNVUzKUPfUsCg5H-5tM,5980
 chromatic/color/palette.py,sha256=I_bS8yKmSL9aNwSWwMyo0MSfcnsHBISXaw9tvAOgAHU,18917
 chromatic/color/palette.pyi,sha256=vGfuKvzcoE_RDuW0kZvAFOqxbkBF1N2-Hbneq46jH94,8795
-chromatic/data/__init__.py,sha256=moB9gGvDHD-XHJbWmQQCjEmsQM5bCa-LrwIq9NMTCKw,546
-chromatic/data/__init__.pyi,sha256=vEuZSlMUaomFCthj1r6Qkdd3WA3wig9pTamK94nIs-Q,364
+chromatic/data/__init__.py,sha256=gr7kEXGXKESgpNXoA40WgMRgMNpslcwP7rvnIelxPDY,602
+chromatic/data/__init__.pyi,sha256=YcidgVmJ34Jr5X4iEE67A8WAPNdoAa38wICdK9r5UOs,420
 chromatic/data/_fetchers.py,sha256=w4j912mDGy8vjZSA0CJUlwxWFgge3ciZEVvdxQQE6aY,1583
 chromatic/data/butterfly.jpg,sha256=rnSfMVotSgpTNRPQ9CzYpDp8S8lkCAJ5ZySRrvyDe7I,448399
 chromatic/data/escher.png,sha256=FvAC-WOkUVIqHBxasfgCJbH1CN1IwLE-JyMiATOEKFc,132667
 chromatic/data/goblin_virus.png,sha256=ygs19t4ZeZYsbiRFXjRyEz8OtgC9Zyl8owX0O-5n40o,8849
 chromatic/data/registry.json,sha256=8fUcLrULUk40qeIQXGC9SOzirp_3D2-5u4lsvHExRHs,269
-chromatic/data/userfont.py,sha256=MresOYGvBY5rAvuaPvv9axBhex-hFC4RAzQjcasuX-0,4861
-chromatic/data/userfont.pyi,sha256=n6dx1aKg0kmt6yqUzKqhH9In8p6ObpPmIAtWjjTaKxM,685
+chromatic/data/userfont.py,sha256=lc-SVLAOwxs8NxlQ5Grdw5xvHo2ZVZZmHtfPs1BFOIs,4399
+chromatic/data/userfont.pyi,sha256=lu0qUFKE-ht_zpEIAgk1pGD0A-_4b7gP0JZycO9pOms,759
 chromatic/data/userfont.schema.json,sha256=nU1qwab5UwibhBBf-jo2p2Q3T-eG7mV8oiF_OKk0NdI,546
 chromatic/data/fonts/consolas.ttf,sha256=xubOgRn91H7GpUSaCOLSrX9B6gMUOq4ZMGjtn6WOrrw,459180
 chromatic/data/fonts/vga437.ttf,sha256=qMdn-pJWJNKNmHnDoDqGIE94vOTezaCiBv0VK92QbJQ,50124
 chromatic/image/__init__.py,sha256=JvSI-emrPJXbvfIDFiF9oEQTwYNGJRT77PTs4IUMKQY,149
 chromatic/image/__init__.pyi,sha256=54B1nzJWJ39BPLFt3hJtn9rFUHFeQ_diMnipA3k7Mc8,1314
-chromatic/image/_array.py,sha256=FH0zgPqn_GcB3X70rYamLXdw-v34d60RaHgl-NAwbyo,40556
-chromatic/image/_curses.py,sha256=O-VxliW8KrGAt1gSru2svGa8h5QaBScEWsnhP7khjFU,3504
+chromatic/image/_array.py,sha256=rVV_-zow859hSzj0C6UOeMqEmBxmpevMEP7r2_9tIG0,41484
+chromatic/image/_curses.py,sha256=VgRfIeb2H1QmltYTErMHzpRGSWm1WKThOqgoeUFzi7U,3494
 chromatic/image/_glyph.py,sha256=gbjV0OZ8gdJr_LSg5pz8-jqepKxgAD2WSszH76z1A2A,2646
-chromatic_python-0.4.1.dist-info/licenses/LICENSE,sha256=fKQvJY6-i5UcR_yGbIv2W7oAehJMTJY0NvRtWoXwHKE,1066
-chromatic_python-0.4.1.dist-info/METADATA,sha256=NibcpQlfgWz_X-zbdbclyxUP2ni8VnvAaNRa0rQ0Fvg,4822
-chromatic_python-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chromatic_python-0.4.1.dist-info/top_level.txt,sha256=wjzxcxfjO8I4u22BS8wL67Bq64c59kbZCqQ--Fc_Mqw,10
-chromatic_python-0.4.1.dist-info/RECORD,,
+chromatic_python-0.4.2.dist-info/METADATA,sha256=mYGRO6KywKgD34ePrOEVL2E-glNfRxdBNNaGYzH88a0,4808
+chromatic_python-0.4.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+chromatic_python-0.4.2.dist-info/top_level.txt,sha256=wjzxcxfjO8I4u22BS8wL67Bq64c59kbZCqQ--Fc_Mqw,10
+chromatic_python-0.4.2.dist-info/RECORD,,

{chromatic_python-0.4.1.dist-info → chromatic_python-0.4.2.dist-info}/WHEEL

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

chromatic_python-0.4.1.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 crypt0lith
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.