chromatic-python 0.3.3__tar.gz → 0.3.4__tar.gz

{chromatic_python-0.3.3/chromatic_python.egg-info → chromatic_python-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chromatic-python
-Version: 0.3.3
+Version: 0.3.4
 Summary: ANSI art image processing and colored terminal text
 Author: crypt0lith
 Project-URL: Homepage, https://github.com/crypt0lith/chromatic

chromatic_python-0.3.4/chromatic/__main__.py

@@ -0,0 +1,105 @@
+from . import __version__, __name__ as prog
+
+
+def banner():
+    from chromatic import read_ans
+    from base64 import b64decode
+    import io
+
+    art = read_ans(
+        io.TextIOWrapper(
+            io.BytesIO(
+                b64decode(
+                    b"""\
+G1swbQ0KICAgICAgICAgICAgICAgICAgG1s5MG36ICAg+vogICAgICAgICAgG1swOzM0bfobWzMy
+bfobWzkxbfobWzkwbSAbWzA7MzRt+vobWzkzbfobWzkxbfobWzA7MzVt+vobWzkwbSAgICAgICAg
+ICAg+iAgIPr6DQobWzBtICAgICAgICAgG1s5MG36ICAgIPouICD6IC4g+vogG1swOzM0bfobWzMy
+bfobWzk0bfobWzkwbSAbWzA7MzVt+htbMzRt+i4bWzkxbfobWzkybS4bWzA7MzRt+htbMzJt+htb
+MzFt+htbMzJtLhtbOTFtLhtbMDszNG36G1s5Mm36G1swOzMxbfobWzMybS4bWzkzbS4bWzA7MzJt
++htbOTFt+htbOTBt+htbMDszNW36G1szNG36G1szMm36G1s5NG36G1s5MG36G1swOzM1bfobWzkw
+bSAg+iAuIPr6IC4g+iAgICD6DQobWzBtICAgG1s5MG0gICAuICAgIC4g+jouICAgICAgG1swOzM0
+bS4bWzMybS4bWzk0bS4bWzkwbS4bWzA7MzVtLhtbMzRtLhtbMzJtLhtbOTFtLhtbMDszNG06G1s5
+NG36G1s5Mm06G1swOzMxbS4bWzM1bTouG1s5MG0gICAgIBtbMDszNG0uLhtbOTJtLhtbMDszMW0u
+G1szMm36G1s5NG36G1swOzMybS4bWzkxbS4bWzkwbSAbWzA7MzVtLhtbMzRtLhtbMzJtLhtbOTRt
+LhtbOTBtIBtbMDszNW0uG1s5MG0gICAgICAuLiD6IC4gICAgLg0KG1swbSAbWzkwbSAgICA6ICAg
+IDogIGw6IC4gICAgG1swOzM0bTobWzMybTobWzk0bTobWzkwbSAbWzA7MzVtOhtbMzRtOhtbMzJt
+OhtbOTFtOhtbMDszNG1sOhtbOTJtbBtbMDszMW06G1szMm0uG1s5NG0uG1s5MG0gG1swOzM1bS4b
+WzkwbSAgG1swOzMybSAgG1szNG0uOhtbOTRtLhtbOTJtOhtbMDszMW06G1szNW06G1szNG06G1sz
+Mm06G1s5MW06G1s5MG1sG1swOzM1bTobWzM0bTobWzMybTobWzk0bTobWzkwbSAbWzA7MzVtOhtb
+OTBtICAgICAuOjogICA6ICAgIDobWzA7MzJtG1szN20NChtbOTBtICAgIGwgICAgbCAgJGwgICA6
+ICAbWzA7MzRtbBtbMzJtbBtbOTRtbBtbOTBtIBtbMDszNW1sG1szNG1sG1szMm1sG1s5MW1sG1sw
+OzM0bSRsG1s5Mm0kG1swOzMxbWwbWzM1bSQbWzM0bTobWzMybTobWzk0bTobWzkwbSAbWzA7MzVt
+OhtbOTBtIBtbMDszMm0gG1szNG06G1szMm06G1s5NG06G1swOzM0bWxsG1s5Mm1sG1swOzMxbWwb
+WzM1bWwbWzM0bWwbWzMybWwbWzkxbWwbWzkwbSAbWzA7MzVtbBtbMzRtbBtbMzJtbBtbOTRtbBtb
+OTBtIBtbMDszNW1sG1s5MG0gICA6ICBsbCAgIGwgICAgbBtbMDszMm0bWzM3bQ0KG1s5MG0gICAk
+ICAgICQgICAkICAgICBsG1swOzM0bSQbWzMybSQbWzk0bSQbWzkwbSAbWzA7MzVtJBtbMzRtJBtb
+MzJtJBtbOTFtJBtbOTBtIBtbMDszNG0kG1szMm0kG1szMW0kG1s5MG0gG1swOzM1bSQbWzkwbSQb
+WzA7MzRtbBtbMzJtbBtbOTRtbBtbOTBtIBtbMDszNW1sG1szNG1sG1szMm1sG1s5NG1sG1s5MG0g
+G1swOzM1bWwbWzM0bSQkG1s5Mm0kG1swOzMxbSQbWzM1bSQbWzM0bSQbWzMybSQbWzkxbSQbWzkw
+bSAbWzA7MzVtJBtbMzRtJBtbMzJtJBtbOTRtJBtbOTBtIBtbMDszNW0kG1s5MG0gbCAgICAkJCAg
+ICQgICAgJBtbMDszMm0bWzM3bQ0KG1s5MG0gICDbICAgINsgICDb3CAgICAgG1swOzM0bdsbWzMy
+bdsbWzk0bdsbWzkwbSQbWzA7MzVt2xtbMzRt2xtbMzJt2xtbOTFt2xtbOTBt3BtbMDszNG3b3Btb
+MzFt2xtbOTJt3BtbMDszNW3b3BtbOTBtIBtbMDszNG0kG1szMm0kG1s5NG0kG1swOzM0bSQbWzMy
+bSQbWzk0bSQbWzkwbSAbWzA7MzVtJBtbMzRt3NsbWzkzbdwbWzkybdsbWzA7MzFt2xtbMzVt2xtb
+MzRt2xtbMzJt2xtbOTFt2xtbOTBtIBtbMDszNW3bG1szNG3bG1szMm3bG1s5NG3bG1s5MG0gG1sw
+OzM1bdsbWzkwbSQgICAg3NvbICAg2yAgICDbG1swOzMybRtbMzdtDQobWzkwbSAgICfcICAgJ9wg
+ICfcN9wuICAbWzA7MzRtJ9wbWzk0bSfcG1swOzM1bScbWzM0bSfcG1s5MW0n3BtbMDszNG0n3Btb
+MzFtJ9wbWzkybTfcLhtbMDszNG3b3BtbOTRt2xtbOTFt3C4bWzk0bdsbWzA7MzRt3BtbOTNtLtw3
+G1s5Mm3cG1swOzMxbdwnG1szNG3cJxtbOTFt3CcbWzA7MzVt3BtbMzRt3CcbWzk0bdwnG1swOzM1
+bdwnG1s5MG3bIC7cN9zcJyAg3CcgICDcJxtbMDszMm0bWzM3bQ0KG1s5MG0gICAgJzfcLiAnN9wu
+JzfcLmpfLBtbMDszNG0nNxtbOTRtJzfcLhtbMDszNG03G1s5MW0nN9wuG1swOzMxbSc33C4bWzkx
+bWobWzA7MzFtXyxq3CxfG1s5MW1qG1swOzMxbS7cNycbWzkxbS7cNycbWzA7MzRt3BtbOTRtLtw3
+JxtbMDszNW03JxtbOTBt3Cxfai7cNycu3DcnIC7cNycbWzA7MzJtG1szN20NChtbOTBtICAgICAg
+ICffN2rcLF83LrCyN2os3GobWzA7MzRtJ98bWzk0bSffN2rcLF8bWzkxbTcbWzk0bS4bWzA7MzFt
+sLI3aizcajeysBtbOTRtLhtbOTFtNxtbOTRtXyzcajffJxtbMDszNW3fJxtbOTBtN2os3Go3srAu
+N18s3Go33ycbWzA7MzJtG1szN20NChtbOTBtICAgICAgICAgICzcajey3N8n39wnJ9zfJ98bWzA7
+MzRtLNwbWzk0bSzcajeyG1swOzMxbdzfG1s5MW0n39wbWzA7MzFtJxtbOTNtJxtbOTFt3N8nG1sw
+OzMxbd/cG1s5NG2yN2rcLBtbMDszNW3cLBtbOTBt3N8n39wnJ9zfJ9/csjdq3CwbWzA7MzJtG1sz
+N20NChtbOTBtICAgICAgICDc3yewICDdsNzdIN0g3t3eG1swOzM0bdzfG1s5NG3c3ycbWzkxbbAb
+WzA7MzRt3bAbWzMxbd2wG1s5NG3cG1s5Mm3dG1swOzMybd0bWzkxbd0bWzA7MzRt3RtbOTFt3t0b
+Wzkzbd7dG1s5NG3cG1swOzMxbbDdG1szNG2wJxtbOTFtsBtbOTRtJ9/cG1swOzM1bd/cG1s5MG3d
+IN0g3t3e3dyw3SAgsCff3BtbMDszMm0bWzM3bQ0KG1s5MG0gICAgICAg3t0gIN/cICDf3N4gICDb
+IBtbMDszNG3e3RtbOTRt3t0bWzA7MzRt39wbWzkxbd/cG1swOzM0bd/cG1szMW3f3BtbOTRt3htb
+MDszNW3cG1szNG3bG1szMm3bG1s5MW3bG1swOzM0bd7cG1s5NG3eG1swOzMxbdzfG1szNG3c3xtb
+OTFt3N8bWzA7MzRt3t0bWzk0bd7dG1swOzM1bd7dG1s5MG0gICDbICDe3N8gINzfICDe3RtbMDsz
+Mm0bWzM3bQ0KG1s5MG0gICAgICAg2yAgICAgNy7c3zcu3SDe3RtbMDszNG3bG1szMm3bG1s5NG3b
+G1s5MG3cG1swOzM1bdsbWzkwbTcbWzA7MzRtNy4bWzkxbTcuG1s5NG3c3xtbMDszMW03LhtbOTFt
+3RtbMDszNG3dG1s5MW3e3RtbMDszMW0uNxtbOTRt39wbWzkxbS43G1swOzM1bS43G1s5MG0gG1sw
+OzM0bdsbWzMybdsbWzk0bdsbWzkwbd8bWzA7MzVt2xtbOTBtLt0g3t0uN9/cLjcgICAgINsbWzA7
+MzJtG1szN20NChtbOTBtICAgICAgIN7dICAgIC7f3z/cJ9/cP98bWzA7MzRt3t0bWzk0bd7dG1sw
+OzM1bd7dG1szNG0u3xtbOTRtLt8bWzkxbd8/3BtbMDszMW0n39w/3ycbWzkxbdw/3xtbOTRt3y4b
+WzA7MzVt3y4bWzM0bd7dG1s5NG3e3RtbMDszNW3e3RtbOTBtJ9/cP98n3D/f3y4gICAg3t0bWzA7
+MzJtG1szN20NChtbOTBtICAgICAgICDf3CAg3F8u3D9fLtzfP9wuG1swOzM0bd/cG1s5NG3f3Btb
+MDszNG3cXxtbOTJt3BtbOTFtXy7cPxtbMDszMW1fLtzfP9wuXxtbOTFtP9wuXxtbMDszNW0uG1sz
+NG3c3xtbOTRt3N8bWzA7MzVt3N8bWzkwbV8u3N8/3C5fP9wuXyAgINzfG1swOzMybRtbMzdtDQob
+WzkwbSAgICAgICAgICLfP9wuXyDf3yIgICAiIt8bWzA7MzRtIt8bWzk0bSLfP9wuXxtbMDszNG3f
+G1szMW3f3yIbWzM1bd8bWzM0bSIiG1s5Mm0iG1swOzMxbSLf3xtbMzRtLhtbOTRtXy7cP98iG1sw
+OzM1bd8iG1s5MG3f3yIgICAiIt/fIF8u3D/fIhtbMDszMm0bWzM3bQ0KG1s5MG0gICAgICAgICAg
+ICAgIt/fICAgICAgICAgIN/fIhtbMDszNG0i3xtbOTRtIt/fG1swOzM1bd/fG1s5MG0gICAbWzA7
+MzJtICAbWzkwbSAbWzA7MzRt398bWzk0bd/fIhtbMDszNW3fIhtbOTBtICLf3yAgICAgICAgICDf
+3yIbWzA7MzJtG1szN20NChtbMG0NChtbOTBtezogXjgwfRtbMG0="""
+                )
+            ),
+            encoding="cp437",
+        )
+    )
+
+    return art.format(f"{prog} {__version__}")
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog=prog,
+        description=banner(),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.parse_args()
+
+
+if __name__ == '__main__':
+    main()

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.3'
-__version_tuple__ = version_tuple = (0, 3, 3)
+__version__ = version = '0.3.4'
+__version_tuple__ = version_tuple = (0, 3, 4)
 
-__commit_id__ = commit_id = 'g23243f5d4'
+__commit_id__ = commit_id = 'gb93479602'

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/color/core.py

@@ -11,6 +11,7 @@ __all__ = [
     'color_chain',
     'colorbytes',
     'get_ansi_type',
+    'is_vt_enabled',
     'randcolor',
     'rgb2ansi_escape',
 ]
@@ -18,6 +19,7 @@ __all__ = [
 import os
 import random
 import re
+import sys
 from collections import Counter
 from collections.abc import Buffer
 from copy import deepcopy
@@ -53,9 +55,9 @@ from .colorconv import (
 )
 from .._typing import AnsiColorAlias, ColorDictKeys, Int3Tuple
 
-os.system('')
+# os.system('')
 
-CSI: Final[bytes] = b'['
+CSI: Final[bytes] = b'\x1b['
 SGR_RESET: Final[bytes] = CSI + b'0m'
 SGR_RESET_S: Final[str] = SGR_RESET.decode()
 
@@ -346,42 +348,48 @@ class ansicolor24Bit(colorbytes):
     alias = '24b'
 
 
-_SUPPORTS_256 = frozenset(
-    [
-        'ANSICON',
-        'COLORTERM',
-        'ConEmuANSI',
-        'PYCHARM_HOSTED',
-        'TERM',
-        'TERMINAL_EMULATOR',
-        'TERM_PROGRAM',
-        'WT_SESSION',
-    ]
-)
-
+if os.name == 'nt':
+    from ctypes import windll, wintypes
 
-def is_vt_proc_enabled():
-    if os.name != 'nt' or os.environ.keys() & _SUPPORTS_256:
-        return True
+    def _enable_vt_processing(handle: int):
+        ENABLE_VT_PROCESSING = 0x0004
+        k32 = windll.kernel32
+        k32.GetStdHandle.restype = wintypes.HANDLE
+        k32.GetConsoleMode.restype = k32.SetConsoleMode.restype = wintypes.BOOL
+        h = k32.GetStdHandle(handle)
+        if h == -1:
+            return False
+        mode = wintypes.DWORD()
+        if not k32.GetConsoleMode(h, byref(mode)):
+            return False
+        mode.value |= ENABLE_VT_PROCESSING
+        return bool(k32.SetConsoleMode(h, mode))
+
+    def is_vt_enabled():
+        if os.environ.keys() & {
+            'ANSICON',
+            'COLORTERM',
+            'ConEmuANSI',
+            'PYCHARM_HOSTED',
+            'TERM',
+            'TERMINAL_EMULATOR',
+            'TERM_PROGRAM',
+            'WT_SESSION',
+        }:
+            return True
+        ok = False
+        for fd, handle in [(sys.stdout, -11), (sys.stderr, -12)]:
+            if getattr(fd, "isatty", lambda: False)():
+                ok |= _enable_vt_processing(handle)
+        return ok
 
-    from ctypes import windll, wintypes
+else:
 
-    STD_OUTPUT_HANDLE = -11
-    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
-    kernel32 = windll.kernel32
-    kernel32.GetStdHandle.restype = wintypes.HANDLE
-    kernel32.GetConsoleMode.restype = kernel32.SetConsoleMode.restype = wintypes.BOOL
-    handle = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
-    if handle == -1:
-        return False
-    mode = wintypes.DWORD()
-    if not kernel32.GetConsoleMode(handle, byref(mode)):
-        return False
-    mode.value |= ENABLE_VIRTUAL_TERMINAL_PROCESSING
-    return kernel32.SetConsoleMode(handle, mode)
+    def is_vt_enabled():
+        return True
 
 
-DEFAULT_ANSI = ansicolor8Bit if is_vt_proc_enabled() else ansicolor4Bit
+DEFAULT_ANSI = ansicolor8Bit if is_vt_enabled() else ansicolor4Bit
 
 AnsiColorFormat: TypeAlias = ansicolor4Bit | ansicolor8Bit | ansicolor24Bit
 AnsiColorType: TypeAlias = type[AnsiColorFormat]
@@ -393,7 +401,7 @@ _ANSI_COLOR_TYPES = cast(
 _ANSI_FORMAT_MAP = {k: x for x in _ANSI_COLOR_TYPES for k in [x, x.alias]}
 
 
-@lru_cache
+@lru_cache(maxsize=len(_ANSI_COLOR_TYPES))
 def _is_ansi_type(typ: type):
     try:
         return typ in _ANSI_COLOR_TYPES
@@ -401,7 +409,7 @@ def _is_ansi_type(typ: type):
         return False
 
 
-@lru_cache
+@lru_cache(maxsize=len(_ANSI_FORMAT_MAP))
 def get_ansi_type(typ):
     try:
         return _ANSI_FORMAT_MAP[typ]
@@ -432,7 +440,7 @@ def set_default_ansi(typ):
 
 
 @lru_cache(maxsize=1)
-def sgr_re_pattern():
+def sgr_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 = (
@@ -445,7 +453,7 @@ def sgr_re_pattern():
 def _split_ansi_escape(__s: str) -> list[tuple['SgrSequence', str]] | None:
     out = []
     i = 0
-    for m in sgr_re_pattern().finditer(__s):
+    for m in sgr_pattern().finditer(__s):
         text = __s[i : (j := m.start())]
         if i != j:
             out.append(text)
@@ -643,8 +651,9 @@ def _iter_normalized_sgr[_T: (
     Buffer,
     SupportsInt,
 )](__iter: bytes | bytearray | Iterable[_T]) -> Iterator[int | AnsiColorFormat]:
-    __iter: ...
-    for elt in __iter.split(b';') if isinstance(__iter, (bytes, bytearray)) else __iter:
+    if isinstance(__iter, (bytes, bytearray)):
+        __iter = __iter.split(b';')
+    for elt in __iter:
         match elt:
             case (colorbytes() as cb) | SgrParamBuffer(colorbytes() as cb):
                 yield cb
@@ -938,44 +947,43 @@ _END_RESET_PATTERN = re.compile(r"\x1b\[0?m$")
 _unset: Any = object()
 
 
-def _make_colorstr[_T: ColorStr](cls: type[_T], obj=_unset, *args, **kwargs) -> _T:
-    sgr = SgrSequence()
-    fg = kwargs.pop('fg', _unset)
-    bg = kwargs.pop('bg', _unset)
-    ansi_type = kwargs.pop('ansi_type', _unset)
-    reset = kwargs.pop('reset', _unset)
-    if kwargs:
-        if not kwargs.keys() <= {'encoding', 'errors'}:
-            raise ValueError(
-                f"unexpected keyword arguments: {(kwargs.keys() - {'encoding', 'errors'})}"
-            )
+def _colorstr[_T: ColorStr](
+    cls: type[_T],
+    obj=_unset,
+    /,
+    fg=None,
+    bg=None,
+    *,
+    encoding=_unset,
+    errors=_unset,
+    ansi_type=_unset,
+    reset=True,
+) -> _T:
+    if buf_kwargs := {
+        k: v
+        for k, v in locals().items()
+        if k in {"encoding", "errors"} and v is not _unset
+    }:
         if not isinstance(obj, Buffer):
-            raise ValueError(
-                "expected buffer or bytes-like object, "
-                f"got {type(obj).__name__!r} object instead"
-            )
-        encoding = kwargs.pop('encoding', 'utf-8')
-        errors = kwargs.pop('errors', 'strict')
-        if isinstance(obj, (bytes, bytearray)):
-            obj = obj.decode(encoding, errors)
-        else:
-            obj = bytes(obj).decode(encoding, errors)
+            raise ValueError(f"unexpected keyword arguments: {set(buf_kwargs)}")
+        elif not isinstance(obj, (bytes, bytearray)):
+            obj = bytes(obj)
+        obj = obj.decode(**buf_kwargs)
+    sgr = SgrSequence()
+
     if obj is not _unset:
         if isinstance(obj, str):
             base_str = str(obj)
-            while m := sgr_re_pattern().match(base_str):
-                sgr.extend(m[0].removeprefix('\x1b[').removesuffix('m').encode())
+            sgr_match = sgr_pattern().match
+            while m := sgr_match(base_str):
+                sgr.extend(m[0].removeprefix("\x1b[").removesuffix('m').encode())
                 base_str = base_str[m.end() :]
             base_str = _END_RESET_PATTERN.sub('', base_str)
         else:
             base_str = str(obj)
     else:
         base_str = ''
-    if '\x1b[' in base_str:
-        raise ValueError
-    if reset is _unset:
-        reset = True
-    elif type(reset) is not bool:
+    if type(reset) is not bool:
         reset = bool(reset)
     if ansi_type is not _unset:
         ansi_type = get_ansi_type(ansi_type)
@@ -987,34 +995,8 @@ def _make_colorstr[_T: ColorStr](cls: type[_T], obj=_unset, *args, **kwargs) ->
             key=lambda x: x[1],
         )[0]
     try:
-        if fg is bg is _unset:
-            match args:
-                case []:
-                    fg = bg = None
-                case [_ as fg]:
-                    bg = None
-                case [_ as fg, _ as bg]:
-                    pass
-                case _:
-                    raise ValueError
-        elif fg is _unset:
-            match args:
-                case []:
-                    fg = None
-                case [_ as fg]:
-                    pass
-                case _:
-                    raise ValueError
-        elif bg is _unset:
-            match args:
-                case []:
-                    bg = None
-                case [_ as bg]:
-                    pass
-                case _:
-                    raise ValueError
-        for k, v in dict.items({'fg': fg, 'bg': bg}):
-            if v is None:
+        for k, v in locals().items():
+            if k not in {"fg", "bg"} or v is None:
                 continue
             match v:
                 case Color(rgb=(_ as r, _ as g, _ as b)):
@@ -1028,27 +1010,21 @@ def _make_colorstr[_T: ColorStr](cls: type[_T], obj=_unset, *args, **kwargs) ->
                 case _:
                     raise TypeError(type(v))
             sgr.append(ansi_type.from_rgb((k, (r, g, b))).to_param_buffer())
-    except (ValueError, TypeError) as e:
-        if isinstance(e, ValueError):
-            err = ValueError(
-                "ColorStr expected at most 2 positional arguments, " f"got {len(args)}"
-            )
-        else:
-            [typ] = e.args
-            err = TypeError(
-                "expected integer or vector of 3 integers, "
-                f"got {typ.__name__!r} object instead"
-            )
+    except TypeError as e:
+        [typ] = e.args
+        err = TypeError(
+            "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 ''])
-    )
+    suffix = SGR_RESET_S if reset else ''
+    inst: Any = str.__new__(cls, f"{sgr}{base_str}{suffix}")
     inst.__dict__ |= {
         '_sgr': sgr,
         '_base_str': base_str,
         '_ansi_type': ansi_type,
-        '_reset': reset,
+        '_reset': suffix,
     }
     return inst
 
@@ -1062,7 +1038,7 @@ class ColorStr(str):
         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 ''
-        inst: Any = str.__new__(type(self), ''.join([str(sgr), base_str, suffix]))
+        inst = super().__new__(type(self), f"{sgr}{base_str}{suffix}")
         inst.__dict__ |= vars(self) | {f'_{k}': v for k, v in kwargs.items()}
         return inst
 
@@ -1070,7 +1046,7 @@ class ColorStr(str):
         r"""Returns a 3-tuple of parts of the string
         (sgr, base string, '\x1B[0m' or '')
         """
-        return str(self._sgr), self.base_str, SGR_RESET_S if self.reset else ''
+        return str(self._sgr), self.base_str, self._reset
 
     def as_ansi_type(self, __ansi_type):
         """Convert all ANSI colors in the `ColorStr` to a single ANSI type.
@@ -1091,10 +1067,7 @@ class ColorStr(str):
         if self.rgb_dict and ansi_type is not self.ansi_format:
             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 '']),
-            )
+            inst = super().__new__(type(self), f"{sgr}{self.base_str}{self._reset}")
             inst.__dict__ |= vars(self) | {'_sgr': sgr, '_ansi_type': ansi_type}
             return inst
         return self
@@ -1288,10 +1261,7 @@ class ColorStr(str):
                 sgr.remove(bx)
             else:
                 sgr.append(bx)
-        inst = super().__new__(
-            type(self),
-            ''.join([str(sgr), self.base_str, SGR_RESET_S if self.reset else '']),
-        )
+        inst = super().__new__(type(self), f"{sgr}{self.base_str}{self._reset}")
         inst.__dict__ |= vars(self) | {
             '_sgr': sgr,
             '_ansi_type': sgr.ansi_type() or self.ansi_format,
@@ -1371,7 +1341,7 @@ class ColorStr(str):
             )
         )
 
-    def ljust(self, __width, __fillchar=" "):
+    def ljust(self, __width, __fillchar=' '):
         return self._weak_var_update(base_str=self.base_str.ljust(__width, __fillchar))
 
     def lower(self):
@@ -1519,7 +1489,7 @@ class ColorStr(str):
         return self._weak_var_update(base_str=self.base_str * __value)
 
     def __new__(cls, obj=_unset, *args, **kwargs):
-        return _make_colorstr(cls, obj, *args, **kwargs)
+        return _colorstr(cls, obj, *args, **kwargs)
 
     def __repr__(self):
         return f'{type(self).__name__}({str(self)!r})'
@@ -1574,7 +1544,7 @@ class ColorStr(str):
 
     @property
     def reset(self):
-        return getattr(self, '_reset')
+        return bool(self._reset)
 
     @property
     def rgb_dict(self):

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/color/core.pyi

@@ -54,7 +54,7 @@ from chromatic._typing import (
     TupleOf3,
 )
 
-
+def is_vt_enabled() -> bool: ...
 @overload
 def get_ansi_type[_T: AnsiColorType](typ: _T) -> _T: ...
 @overload
@@ -68,7 +68,7 @@ def randcolor() -> Color: ...
 def rgb2ansi_escape(
     fmt: AnsiColorAlias | AnsiColorType, mode: ColorDictKeys, rgb: Int3Tuple
 ) -> bytes: ...
-def sgr_re_pattern() -> re.Pattern[str]: ...
+def sgr_pattern() -> re.Pattern[str]: ...
 
 class ansicolor4Bit(colorbytes):
     alias: ClassVar[L['4b']]
@@ -266,6 +266,7 @@ class ColorStr(str):
     @property
     def rgb_dict(self) -> MappingProxyType[ColorDictKeys, Int3Tuple]: ...
     _sgr: SgrSequence
+    _reset: L["\x1b[0m", ""]
 
 class _ColorChainKwargs(TypedDict, total=False):
     ansi_type: AnsiColorAlias | type[AnsiColorFormat]

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/color/palette.py

@@ -417,7 +417,7 @@ class _color_ns_getter:
             raise err
 
 
-def rgb_dispatch(names=()):
+def rgb_dispatch(*names: str):
     def decorator(__f):
         def fix_signature(__f):
             from .._typing import eval_annotation
@@ -430,9 +430,9 @@ def rgb_dispatch(names=()):
                 if not (isbuiltin(__f) or getattr(__f, '__module__', '') == 'builtins'):
                     raise
                 return signature(lambda *args, **kwargs: ...)
-            variadic = set(
+            variadic = {
                 name for name in [argspec.varargs, argspec.varkw] if name is not None
-            )
+            }
             all_arg_names = variadic.union(argspec.args + argspec.kwonlyargs)
             rgb_args = all_arg_names.intersection(
                 dict.get({'*': argspec.varargs, '**': argspec.varkw}, arg, arg)
@@ -491,21 +491,16 @@ def rgb_dispatch(names=()):
             setattr(__f, '__signature__', wrapper_sig)
         return update_wrapper(wrapper, __f)
 
-    if callable(names):
-        user_func, names = names, ()
-        return decorator(user_func)
-    elif isinstance(names, tuple):
-        if any(type(x) is not str for x in names):
-            clsname = next(t for t in map(type, names) if t is not str).__name__
+    if names and callable(names[0]):
+        func, *names = names
+    else:
+        func = None
+    for x in names:
+        if type(x) is not str:
             raise TypeError(
-                f"expected tuple of strings, "
-                f"got tuple containing {clsname!r} object instead"
+                f"found {type(x).__name__!r} object in names, expected only str"
             )
-        return decorator
-    raise TypeError(
-        "expected callable or variable names tuple, "
-        f"got {type(names).__name__!r} object instead"
-    )
+    return decorator if func is None else decorator(func)
 
 
 def _make_named_color_map() -> ...:
@@ -564,19 +559,19 @@ named_color = _make_named_color_map()
 
 def named_color_idents():
     return [
-        ColorStr(name.replace('_', ' ').lower(), color, ansi_type='24b')
+        ColorStr(name.translate({0x5F: 0x20}).lower(), color, ansi_type='24b')
         for name, color in ColorNamespace.asdict().items()
     ]
 
 
-def __getattr__(name: ...) -> ...:
-    if name == 'Back':
-        return AnsiBack()
-    if name == 'Fore':
-        return AnsiFore()
-    if name == 'Style':
-        return AnsiStyle()
-    raise AttributeError(f"Module {__name__!r} has no attribute {name!r}")
+def __getattr__(name: str) -> ...:
+    try:
+        return globals().setdefault(
+            name, {'Back': AnsiBack, 'Fore': AnsiFore, 'Style': AnsiStyle}[name]()
+        )
+    except KeyError:
+        pass
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
 if TYPE_CHECKING:

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/color/palette.pyi

@@ -291,11 +291,9 @@ class ColorNamespace[NamedColor = Color](DynamicNamespace[NamedColor]):
 named_color: MappingProxyType[tuple[Literal['4b', '24b'], str], Color]
 
 @overload
-def rgb_dispatch[_F: Callable[..., Any]](__f: _F, /) -> _F: ...
+def rgb_dispatch[_F: Callable[..., Any]](__f: _F, /, *names: str) -> _F: ...
 @overload
-def rgb_dispatch[_F: Callable[..., Any]](
-    names: tuple[str, ...] = (),
-) -> Callable[[_F], _F]: ...
+def rgb_dispatch[_F: Callable[..., Any]](*names: str) -> Callable[[_F], _F]: ...
 
 Back: AnsiBack
 Fore: AnsiFore

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/data/userfont.py

@@ -1,7 +1,7 @@
 import json
 import os
 import os.path as osp
-from dataclasses import dataclass, field
+from dataclasses import field, dataclass, MISSING, fields
 from types import MappingProxyType
 from typing import AnyStr, TYPE_CHECKING
 
@@ -23,7 +23,7 @@ if not osp.exists(os.environ["CHROMATIC_FONTDIR"]):
 _TRUETYPE_EXT = frozenset({'.ttf', '.ttc'})
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, slots=True, repr=False)
 class UserFont:
     font: str
     size: int = field(default=24, kw_only=True)
@@ -38,6 +38,21 @@ 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
 

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/demo.py

@@ -4,9 +4,15 @@ import sys
 import time
 from os import PathLike
 from pathlib import PurePath
+from random import choices as get_random
 from types import FunctionType
 from typing import Callable
 
+from numpy import ndarray
+from skimage.metrics import mean_squared_error
+
+import chromatic as cm
+
 
 class FunctionNamespace:
 
@@ -21,35 +27,23 @@ DEMO_FUNCS = FunctionNamespace()
 @DEMO_FUNCS.register
 def escher_dragon_ascii():
     """Displays the image-to-ASCII transform of 'Dragon' by M.C. Escher."""
-    from chromatic.image import ascii2img, img2ascii
-    from chromatic.data import userfont, escher
-
-    input_img = escher()
-    font = userfont['vga437']
+    input_img = cm.data.escher()
+    font = cm.userfont['vga437']
     char_set = r"  ._-~+<vX♦'^Vx>|πΦ0Ω#$║╫"
-
-    ascii_str = img2ascii(
+    ascii_str = cm.img2ascii(
         input_img, font, factor=240, char_set=char_set, sort_glyphs=True
     )
-
-    ascii_img = ascii2img(ascii_str, font, font_size=16, fg='white', bg='black')
-
+    ascii_img = cm.ascii2img(ascii_str, font, font_size=16, fg='white', bg='black')
     ascii_img.show()
 
 
 @DEMO_FUNCS.register
 def escher_dragon_256color():
     """Displays the image-to-ANSI transform of 'Dragon' by M.C. Escher in 8-bit color."""
-    from chromatic.image import ansi2img, img2ansi
-    from chromatic.data import userfont, escher
-
-    input_img = escher()
-    font = userfont['vga437']
-
-    ansi_array = img2ansi(input_img, font, factor=240, ansi_type='8b', equalize=True)
-
-    ansi_img = ansi2img(ansi_array, font, font_size=16)
-
+    input_img = cm.data.escher()
+    font = cm.userfont['vga437']
+    ansi_array = cm.img2ansi(input_img, font, factor=240, ansi_type='8b', equalize=True)
+    ansi_img = cm.ansi2img(ansi_array, font, font_size=16)
     ansi_img.show()
 
 
@@ -59,101 +53,72 @@ def butterfly_16color():
 
     Good ol' C-x M-c M-butterfly...
     """
-    from chromatic.color import ansicolor4Bit
-    from chromatic.image import ansi2img, img2ansi
-    from chromatic.data import userfont, butterfly
-
-    input_img = butterfly()
-
-    font = userfont['vga437']
-
+    input_img = cm.data.butterfly()
+    font = cm.data.userfont['vga437']
     char_set = r"'·,•-_→+<>ⁿ*%⌂7√Iï∞πbz£9yîU{}1αHSw♥æ?GX╕╒éà⌡MF╝╩ΘûǃQ½☻Ŷ┤▄╪║▒█"
-
-    ansi_array = img2ansi(
-        input_img, font, factor=200, char_set=char_set, ansi_type=ansicolor4Bit
+    ansi_array = cm.img2ansi(
+        input_img,
+        font,
+        factor=200,
+        char_set=char_set,
+        equalize=True,
+        ansi_type=cm.ansicolor4Bit,
     )
-
-    ansi_img = ansi2img(ansi_array, font, font_size=16)
-
+    ansi_img = cm.ansi2img(ansi_array, font, font_size=16)
     ansi_img.show()
 
 
 @DEMO_FUNCS.register
 def butterfly_truecolor():
     """Displays the image-to-ANSI transform of 'Spider Lily & Papilio xuthus' in 24-bit color."""
-    from chromatic.image import ansi2img, img2ansi
-    from chromatic.data import userfont, butterfly
-
-    input_img = butterfly()
-
-    font = userfont['vga437']
-
-    ansi_array = img2ansi(
+    input_img = cm.data.butterfly()
+    font = cm.userfont['vga437']
+    ansi_array = cm.img2ansi(
         input_img, font, factor=200, ansi_type='24b', equalize='white_point'
     )
-
-    ansi_img = ansi2img(ansi_array, font, font_size=16)
-
+    ansi_img = cm.ansi2img(ansi_array, font, font_size=16)
     ansi_img.show()
 
 
 @DEMO_FUNCS.register
 def butterfly_randcolor():
-    from chromatic.image import ansi2img, img2ansi
-    from chromatic.color import randcolor, rgb2hsv, hsv2rgb, Color
-    from chromatic.data import userfont, butterfly
-
-    input_img = butterfly()
-
-    font = userfont['vga437']
-
-    ansi_array = img2ansi(
+    input_img = cm.data.butterfly()
+    font = cm.userfont['vga437']
+    ansi_array = cm.img2ansi(
         input_img, font, factor=200, ansi_type='8b', equalize='white_point'
     )
-
     for row in range(len(ansi_array)):
         for idx, cs in enumerate(ansi_array[row]):
             if (fg := cs.fg) is not None:
-                _, _, v = rgb2hsv(fg.rgb)
-                h, s, _ = rgb2hsv(randcolor().rgb)
-                ansi_array[row][idx] = cs.recolor(fg=Color.from_rgb(hsv2rgb((h, s, v))))
-
-    ansi_img = ansi2img(ansi_array, font, font_size=16)
-
+                _, _, v = cm.color.rgb2hsv(fg.rgb)
+                h, s, _ = cm.color.rgb2hsv(cm.color.randcolor().rgb)
+                ansi_array[row][idx] = cs.recolor(
+                    fg=cm.Color.from_rgb(cm.color.hsv2rgb((h, s, v)))
+                )
+    ansi_img = cm.ansi2img(ansi_array, font, font_size=16)
     ansi_img.show()
 
 
 @DEMO_FUNCS.register
 def goblin_virus_truecolor():
     """`G-O-B-L-I-N VIRUS <https://imgur.com/n0Mng2P>`__"""
-    from chromatic.image import ansi2img, img2ansi
-    from chromatic.data import userfont, goblin_virus
-
-    input_img = goblin_virus()
-
-    font = userfont['vga437']
-
+    input_img = cm.data.goblin_virus()
+    font = cm.userfont['vga437']
     char_set = r'  .-|_⌐¬^:()═+<>v≥≤«*»x└┘π╛╘┴┐┌┬╧╚╙X╒╜╨#0╓╝╩╤╥│╔┤├╞╗╦┼╪║╟╠╫╣╬░▒▓█▄▌▐▀'
-
-    ansi_array = img2ansi(
+    ansi_array = cm.img2ansi(
         input_img, font, factor=200, char_set=char_set, ansi_type='24b', equalize=False
     )
-
-    ansi_img = ansi2img(ansi_array, font, font_size=16)
-
+    ansi_img = cm.ansi2img(ansi_array, font, font_size=16)
     ansi_img.show()
 
 
 @DEMO_FUNCS.register
 def named_colors():
-    from chromatic.color.palette import named_color_idents, ColorNamespace
-    from chromatic.color.colorconv import rgb2hsv, rgb2lab
-
-    print(f"{'.'.join([ColorNamespace.__module__, ColorNamespace.__name__])}:")
-    named = named_color_idents()
+    print("{0.__module__}.{0.__name__}:".format(cm.ColorNamespace))
+    named = cm.color.palette.named_color_idents()
     whites = [0]
     for idx, n in enumerate(named):
-        hsv = rgb2hsv(n.fg.rgb)
+        hsv = cm.color.rgb2hsv(n.fg.rgb)
         if all(
             map(lambda i, x: math.isclose(hsv[i], x, abs_tol=0.16), (-1, 1), (1, 0))
         ):
@@ -161,33 +126,33 @@ def named_colors():
                 whites.pop()
             whites.append(idx)
     whites.append(-1)
-    buffer = []
     for start, stop in zip(whites, whites[1:]):
         xs = sorted(
             named[start + 1 if start else None : stop + 1 if ~stop else None],
-            key=lambda x: rgb2lab(x.fg.rgb),
+            key=lambda x: cm.color.rgb2lab(x.fg.rgb),
         )
-        buffer.append(xs)
-    for line in buffer:
-        print(' | '.join(line))
+        print(' | '.join(xs))
 
 
 @DEMO_FUNCS.register
 def color_cube():
     """Print the ANSI256 6x6x6 color cube"""
     fmt_code = lambda n: f"\x1b[48;5;{n}m{n: >4}"
-    for i in range(0, 8, 4):
-        for j in range(i, i + 8):
-            print(fmt_code(i + j), end='')
-        else:
+    ansi_256_codes = iter(range(0x100))
+    for i in range(0x10):
+        if i and i % 8 == 0:
             print("\x1b[m")
-    for i in range(6):
-        for j in range(0x10, 0xE8, 6):
-            print(fmt_code(i + j), end='')
-        else:
+        print(fmt_code(next(ansi_256_codes)), end='')
+    else:
+        print("\x1b[m")
+    for i in range(6**3):
+        if i and i % 6**2 == 0:
             print("\x1b[m")
-    for i in range(0xE8, 0x100):
-        print(fmt_code(i), end='')
+        print(fmt_code(next(ansi_256_codes)), end='')
+    else:
+        print("\x1b[m")
+    for x in ansi_256_codes:
+        print(fmt_code(x), end='')
     else:
         print("\x1b[m")
 
@@ -198,20 +163,11 @@ def color_table():
 
     A handful of stylistic SGR parameters are displayed as well.
     """
-    from chromatic.color import (
-        ColorStr,
-        Color,
-        SgrParameter,
-        ansicolor24Bit,
-        ansicolor4Bit,
-        ansicolor8Bit,
-        ColorNamespace,
-    )
 
-    ansi_types = [ansicolor4Bit, ansicolor8Bit, ansicolor24Bit]
+    ansi_types = [cm.ansicolor4Bit, cm.ansicolor8Bit, cm.ansicolor24Bit]
 
-    colors: dict[str, Color] = {
-        name.title(): getattr(ColorNamespace, name)
+    colors: dict[str, cm.Color] = {
+        name.title(): getattr(cm.ColorNamespace, name)
         for name in [
             'BLACK',
             'WHITE',
@@ -226,10 +182,10 @@ def color_table():
     }
     spacing = max(map(len, colors)) + 1
     fg_colors = [
-        ColorStr(f"{name: ^{spacing}}", fg=color, ansi_type=ansicolor24Bit)
+        cm.ColorStr(f"{name: ^{spacing}}", fg=color, ansi_type=cm.ansicolor24Bit)
         for name, color in colors.items()
     ]
-    bg_colors = [ColorStr().recolor(bg=None)] + [
+    bg_colors = [cm.ColorStr().recolor(bg=None)] + [
         c.recolor(fg=None, bg=c.fg) for c in fg_colors
     ]
     print(
@@ -244,36 +200,24 @@ def color_table():
         print()
     print('\nstyles:', end='\t')
     style_params = [
-        SgrParameter.BOLD,
-        SgrParameter.ITALICS,
-        SgrParameter.CROSSED_OUT,
-        SgrParameter.ENCIRCLED,
-        SgrParameter.SINGLE_UNDERLINE,
-        SgrParameter.DOUBLE_UNDERLINE,
-        SgrParameter.NEGATIVE,
+        cm.SgrParameter.BOLD,
+        cm.SgrParameter.ITALICS,
+        cm.SgrParameter.CROSSED_OUT,
+        cm.SgrParameter.ENCIRCLED,
+        cm.SgrParameter.SINGLE_UNDERLINE,
+        cm.SgrParameter.DOUBLE_UNDERLINE,
+        cm.SgrParameter.NEGATIVE,
     ]
-    for style in style_params[:-1]:
+    for style in style_params:
         print(
-            ColorStr('.'.join([SgrParameter.__qualname__, style.name])).update_sgr(
+            cm.ColorStr(f"{cm.SgrParameter.__qualname__}.{style.name}").update_sgr(
                 style
             ),
-            end='\x1b[0m'.ljust(8),
-        )
-    else:
-        print(
-            ColorStr(f"{SgrParameter.__qualname__}.{style_params[-1].name}").update_sgr(
-                style_params[-1]
-            )
+            end=('\n' if style is style_params[-1] else "\x1b[0m".ljust(8)),
         )
 
 
 def glyph_comparisons(__output_dir: str | PathLike[str] = None):
-    from chromatic import get_glyph_masks
-    from chromatic.data import userfont
-    from chromatic.image import cp437_printable
-    from numpy import ndarray
-    from random import choices as get_random
-    from skimage.metrics import mean_squared_error
 
     def _find_best_matches(
         glyph_masks1: dict[str, ndarray], glyph_masks2: dict[str, ndarray]
@@ -292,13 +236,13 @@ def glyph_comparisons(__output_dir: str | PathLike[str] = None):
 
     if __output_dir and not os.path.isdir(__output_dir):
         raise NotADirectoryError(__output_dir)
-    user_fonts = [pair := (userfont['vga437'], userfont['consolas']), pair[::-1]]
+    user_fonts = [pair := (cm.userfont['vga437'], cm.userfont['consolas']), pair[::-1]]
     trans_table = str.maketrans({']': None, '0': ' ', '[': ' '})
-    char_set = cp437_printable()
+    char_set = cm.cp437_printable()
     separator = '#' * 100
     for font1, font2 in user_fonts:
-        glyph_masks_1 = get_glyph_masks(font1, char_set, dist_transform=True)
-        glyph_masks_2 = get_glyph_masks(font2, char_set, dist_transform=True)
+        glyph_masks_1 = cm.get_glyph_masks(font1, char_set, dist_transform=True)
+        glyph_masks_2 = cm.get_glyph_masks(font2, char_set, dist_transform=True)
         best_matches_ = _find_best_matches(glyph_masks_1, glyph_masks_2)
         txt = ''.join(
             '->'.center(32, ' ')

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic/image/_array.py

@@ -52,7 +52,7 @@ from ..color.core import (
     ansicolor4Bit,
     ansicolor8Bit,
     get_ansi_type,
-    sgr_re_pattern,
+    sgr_pattern,
 )
 from ..color.palette import rgb_dispatch
 from ..data import UserFont, userfont
@@ -366,7 +366,7 @@ def ansi_quantize(
     img: RGBArray,
     ansi_type: type[ansicolor4Bit | ansicolor8Bit],
     *,
-    equalize: bool | Literal['white_point'] = True,
+    equalize: bool | Literal['white_point'] = False,
 ):
     """Color-quantize an RGB array into ANSI 4-bit or 8-bit color space.
 
@@ -583,7 +583,7 @@ def img2ascii(
     return ascii_str
 
 
-@rgb_dispatch(('bg',))
+@rgb_dispatch('bg')
 def img2ansi(
     __img: RGBImageLike | PathLike[str] | str,
     __font: FontArgType = userfont['vga437'],
@@ -591,7 +591,7 @@ def img2ansi(
     char_set: Iterable[str] = None,
     ansi_type: AnsiColorParam = DEFAULT_ANSI,
     sort_glyphs: bool | type[reversed] = True,
-    equalize: bool | Literal['white_point'] = True,
+    equalize: bool | Literal['white_point'] = False,
     bg: Color | Int3Tuple | str = (0, 0, 0),
 ):
     """Convert an image to an ANSI array.
@@ -681,7 +681,7 @@ def img2ansi(
     return xs
 
 
-@rgb_dispatch(('fg', 'bg'))
+@rgb_dispatch('fg', 'bg')
 def ascii2img(
     __ascii: str,
     __font: FontArgType = userfont['vga437'],
@@ -733,7 +733,7 @@ def ascii2img(
     return img
 
 
-@rgb_dispatch(('fg_default', 'bg_default'))
+@rgb_dispatch('fg_default', 'bg_default')
 def ansi2img(
     __ansi_array: list[list[ColorStr]],
     __font: FontArgType = userfont['vga437'],
@@ -829,7 +829,7 @@ def ansify(
     char_set: Iterable[str] = None,
     sort_glyphs: bool | type[reversed] = True,
     ansi_type: AnsiColorParam = DEFAULT_ANSI,
-    equalize: bool | Literal['white_point'] = True,
+    equalize: bool | Literal['white_point'] = False,
     fg: Int3Tuple | str = (170, 170, 170),
     bg: Int3Tuple | str | Literal['auto'] = (0, 0, 0),
 ):
@@ -886,8 +886,8 @@ def _is_csi_param(__c: str) -> TypeGuard[Literal[';'] | LiteralDigit]:
 
 
 @lru_cache(maxsize=1)
-def sgr_span_re_pattern():
-    sgr_re = sgr_re_pattern().pattern.removeprefix(r'\x1b\[')
+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]*)"
     )
@@ -951,7 +951,7 @@ def _sub_bold_colors(lines: Iterable[str]) -> Iterator[str]:
     for line in lines:
         bold_bit = False
         prev_colors = {}
-        yield sgr_re_pattern().sub(sub, line)
+        yield sgr_pattern().sub(sub, line)
 
 
 def reshape_ansi(__str: str, w: int, h: int) -> str:
@@ -982,7 +982,7 @@ def reshape_ansi(__str: str, w: int, h: int) -> str:
     cur = cursor()
     x, y = next(cur)
     for line in _sub_bold_colors(__str.splitlines()):
-        for m in sgr_span_re_pattern().finditer(line + '\n'):
+        for m in cursor_or_sgr_pattern().finditer(line + '\n'):
             if cg := m['cursor']:
                 write_cell(' ')
                 param, code = cg[:-1], cg[-1]
@@ -1018,10 +1018,10 @@ def reshape_ansi(__str: str, w: int, h: int) -> str:
                 write_cell(ch, incr=True)
 
     out_lines = []
-    any_sgr_re = re.compile(r"\x1b\[\d*(?:;\d*)*[A-HJ-KS-Tmf]")
+    any_ansi_seq = re.compile(r"\x1b\[\d*(?:;\d*)*[A-HJ-KS-Tmf]")
     for row in arr:
         out_row = ''.join(cell.translate({0: ' '}) for cell in row)
-        lhs, rhs = map(' '.__mul__, divmod(w - len(any_sgr_re.sub('', out_row)), 2))
+        lhs, rhs = map(' '.__mul__, divmod(w - len(any_ansi_seq.sub('', out_row)), 2))
         out_lines.append(f"{lhs}{out_row}{rhs}")
 
     return '\n'.join(out_lines)
@@ -1034,7 +1034,7 @@ def to_sgr_array(__str: str, ansi_type: AnsiColorParam = None):
     xs = []
     for line in _sub_bold_colors(__str.splitlines()):
         x = []
-        for m in sgr_span_re_pattern().finditer(line):
+        for m in cursor_or_sgr_pattern().finditer(line):
             text = m["text"]
             if m["sgr"]:
                 sgr = SgrSequence(map(int, m["sgr"].removesuffix('m').split(';')))

{chromatic_python-0.3.3 → chromatic_python-0.3.4/chromatic_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chromatic-python
-Version: 0.3.3
+Version: 0.3.4
 Summary: ANSI art image processing and colored terminal text
 Author: crypt0lith
 Project-URL: Homepage, https://github.com/crypt0lith/chromatic

{chromatic_python-0.3.3 → chromatic_python-0.3.4}/chromatic_python.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ pyproject.toml
 requirements.txt
 chromatic/__init__.py
 chromatic/__init__.pyi
+chromatic/__main__.py
 chromatic/_typing.py
 chromatic/_version.py
 chromatic/demo.py