chromatic-python 0.9.0__tar.gz → 0.9.2__tar.gz

chromatic_python-0.9.2/.github/workflows/build.yml

@@ -0,0 +1,33 @@
+name: build
+
+on: [workflow_dispatch, push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.12', '3.13', '3.14']
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install OpenCV runtime libraries
+        run: sudo apt-get update && sudo apt-get install -y libgl1
+      - run: uv run --group tests pytest
+
+  bench:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v7
+      - name: Install OpenCV runtime libraries
+        run: sudo apt-get update && sudo apt-get install -y libgl1
+      - uses: CodSpeedHQ/action@v5
+        with:
+          mode: simulation
+          run: uv run --group tests pytest --codspeed

{chromatic_python-0.9.0 → chromatic_python-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chromatic-python
-Version: 0.9.0
+Version: 0.9.2
 Summary: ANSI art image processing and colored terminal text
 Author: crypt0lith
 License-Expression: MIT
@@ -31,6 +31,7 @@ Dynamic: license-file
 ![image](https://img.shields.io/pypi/pyversions/chromatic-python)
 [![image](https://static.pepy.tech/badge/chromatic-python)](https://pepy.tech/projects/chromatic-python)
 [![image](https://mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://app.codspeed.io/crypt0lith/chromatic?utm_source=badge)
 
 Chromatic is a library for ANSI art image processing and colored terminal text.
 
@@ -45,127 +46,127 @@ It offers a collection of algorithms and types for a variety of use cases:
 
 ### Usage
 
-#### `color_chain`
+#### `ColorStr`
+
+```python
+from chromatic import ColorStr
+
+cs = ColorStr("hello world", fg=0xFF0000, ansi_type="8b")
+
+assert cs.base_str == "hello world"
+assert len(cs) == len("hello world")
+
+head, tail = cs.split()
+
+assert head.fg == tail.fg == cs.fg
+assert all(c.fg == cs.fg for c in cs)
+```
+
+`ColorStr` is a `str` subclass that carries SGR state as metadata.
+Its `str` methods delegate to the base string and return `ColorStr` instances that retain the SGR state.
+
+```python
+assert str(cs) == "\x1b[38;5;196mhello world\x1b[0m"
+assert cs.ansi == b"\x1b[38;5;196m"
+```
+
+The SGR sequence materializes when the `ColorStr` is converted back to a Python `str`.
 
-A `color_chain` is a printable sequence of colored text that round-trips with a NumPy array:
+#### `color_chain`
 
 ```python
-from chromatic import color_chain, ColorStr
+from chromatic import color_chain
 
 cc = color_chain(
     [ColorStr("hello", fg=0xFF0000), ColorStr(" world", fg=0x00FF00)], ansi_type="8b"
 )
 
-# parsed from a raw SGR string — no ansi_type needed
+sgr, s = cc[0]
+
+assert sgr.fg == (0xFF, 0, 0)
+assert s == "hello"
+```
+
+A `color_chain` is a sequence of colored-text fragments that round-trips with a structured NumPy array.
+Each fragment is an `(sgr, text)` pair of the SGR state and the run of text it applies to.
+
+```python
 cc2 = color_chain("\x1b[38;5;196mhello\x1b[38;5;46m world")
 
 assert cc == cc2
+```
 
-# red "hello", green " world"
-print(cc)
+The constructor also parses a raw SGR string.
+It infers the color depth from the sequence, so `cc2` needs no `ansi_type`.
 
-# a structured ndarray of dtype [('char', '<U1'), ('sgr', '<u8'), ('rgb', 'u1', (2, 4))]
+```python
 arr = cc.term_array()
 
+assert arr.dtype == [("char", "<U1"), ("sgr", "<u8"), ("rgb", "u1", (2, 4))]
 assert str(color_chain.fromarray(arr)) == str(cc)
 ```
 
-#### `img2ansi`
+`term_array` exposes the structured `ndarray` behind the chain, and `fromarray` reverses it.
+`fromarray` accepts any `ndarray` of that dtype, so an array built by other means converts to a printable `color_chain`.
 
-`img2ansi` reads an image and returns a `color_chain`:
+#### `img2ansi`
 
 ```python
 from chromatic import img2ansi
-from chromatic.data import userfonts
-
-font = userfonts["vga437"]
-
-# the image, as ANSI art
-cc = img2ansi("input.png", font, factor=200)
-print(cc)
 
-# or the raw ndarray
-arr = img2ansi("input.png", font, factor=200, outarray=True)
+cc = img2ansi("input.png")
 ```
 
-#### `ansi2img`
-
-`ansi2img` renders a `color_chain` (or array) back to an image:
+`img2ansi` reads an image and returns a `color_chain`.
 
 ```python
-from chromatic import img2ansi, ansi2img
-from chromatic.data import userfonts
-
-font = userfonts["vga437"]
-
-cc = img2ansi("input.png", font, factor=200)
+arr = img2ansi("input.png", outarray=True)
 
-# a PIL.Image.Image
-img = ansi2img(cc, font, font_size=16)
-img.show()
+assert color_chain.fromarray(arr) == cc
 ```
 
-#### `ansify`
+`outarray=True` returns the underlying `ndarray` instead.
 
-`ansify` runs both steps at once, returning the rendered image with its array on `Image.info`:
+#### `ansi2img`
 
 ```python
-from chromatic import ansify
-from chromatic.data import userfonts
+from chromatic import ansi2img
 
-font = userfonts["vga437"]
-
-img = ansify("input.png", font, font_size=16, factor=200)
+img = ansi2img(cc)
 img.show()
-
-# the ndarray it rendered from
-arr = img.info["ansi_array"]
 ```
 
-#### Animated images
+`ansi2img` renders a `color_chain` back to an image.
+It also accepts a dtype-matching array.
 
-An animated image becomes a list of `color_chain` frames, one per frame — so a GIF plays straight to the terminal:
+#### `ansify`
 
 ```python
-import sys
-import time
-
-from chromatic import img2ansi
-from chromatic.data import userfonts
-
-font = userfonts["vga437"]
-
-# list[color_chain], one per frame
-frames = img2ansi("input.gif", font, factor=200)
+from chromatic import ansify
 
-for cc in frames:
-    # redraw each frame in place
-    sys.stdout.write(f"\x1b[H{cc}")
-    time.sleep(0.1)
+img = ansify("input.png")
+arr = img.info["ansi_array"]
 ```
 
-`ansify` renders the same GIF back to an animated image, and `chromatic image ansify input.gif --stdout` plays it in the terminal for you.
-
-#### `ColorStr`
+`ansify` runs both directions in one call, returning the rendered image with the array it rendered from on `Image.info`.
 
-`ColorStr` is a `str` subclass that carries its SGR color as metadata; the escape codes only surface when you render it:
+#### Animated images
 
 ```python
-from chromatic import ColorStr
-
-cs = ColorStr("hello world", fg=0xFF0000, ansi_type="8b")
+frames = img2ansi("input.gif")
 
-assert isinstance(cs, str)
+assert isinstance(frames, list)
+assert all(isinstance(f, color_chain) for f in frames)
+```
 
-# the codes aren't part of the string itself
-assert cs.base_str == "hello world"
-assert len(cs) == len("hello world")
+An animated image renders to a `list[color_chain]`, one per frame.
 
-# they surface when you print / str() it
-assert str(cs) == "\x1b[38;5;196mhello world\x1b[0m"
-assert cs.ansi == b"\x1b[38;5;196m"
+```shell
+chromatic image ansify input.gif --stdout
 ```
 
+The [CLI](https://crypt0lith.github.io/chromatic/cli/image/#chromatic-image-ansify) renders and plays one straight to the terminal.
+
 ### Installation
 
 Install the package using `pip`:

chromatic_python-0.9.2/README.md

@@ -0,0 +1,153 @@
+![image](https://raw.githubusercontent.com/crypt0lith/chromatic/master/banner.png)
+
+[![image](https://img.shields.io/pypi/v/chromatic-python)](https://pypi.org/project/chromatic-python/)
+![image](https://img.shields.io/pypi/pyversions/chromatic-python)
+[![image](https://static.pepy.tech/badge/chromatic-python)](https://pepy.tech/projects/chromatic-python)
+[![image](https://mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://app.codspeed.io/crypt0lith/chromatic?utm_source=badge)
+
+Chromatic is a library for ANSI art image processing and colored terminal text.
+
+It offers a collection of algorithms and types for a variety of use cases:
+
+- Image-to-ASCII / Image-to-ANSI conversions.
+- ANSI art rendering, with support for user-defined fonts.
+- A `ColorStr` type for low-level control over ANSI SGR strings.
+- [colorama](https://github.com/tartley/colorama/)-style wrappers (`Fore`, `Back`, `Style`).
+- Conversion between 16-color, 256-color, and true-color (RGB) ANSI colorspace via the `colorbytes` type.
+- Et Cetera 😲
+
+### Usage
+
+#### `ColorStr`
+
+```python
+from chromatic import ColorStr
+
+cs = ColorStr("hello world", fg=0xFF0000, ansi_type="8b")
+
+assert cs.base_str == "hello world"
+assert len(cs) == len("hello world")
+
+head, tail = cs.split()
+
+assert head.fg == tail.fg == cs.fg
+assert all(c.fg == cs.fg for c in cs)
+```
+
+`ColorStr` is a `str` subclass that carries SGR state as metadata.
+Its `str` methods delegate to the base string and return `ColorStr` instances that retain the SGR state.
+
+```python
+assert str(cs) == "\x1b[38;5;196mhello world\x1b[0m"
+assert cs.ansi == b"\x1b[38;5;196m"
+```
+
+The SGR sequence materializes when the `ColorStr` is converted back to a Python `str`.
+
+#### `color_chain`
+
+```python
+from chromatic import color_chain
+
+cc = color_chain(
+    [ColorStr("hello", fg=0xFF0000), ColorStr(" world", fg=0x00FF00)], ansi_type="8b"
+)
+
+sgr, s = cc[0]
+
+assert sgr.fg == (0xFF, 0, 0)
+assert s == "hello"
+```
+
+A `color_chain` is a sequence of colored-text fragments that round-trips with a structured NumPy array.
+Each fragment is an `(sgr, text)` pair of the SGR state and the run of text it applies to.
+
+```python
+cc2 = color_chain("\x1b[38;5;196mhello\x1b[38;5;46m world")
+
+assert cc == cc2
+```
+
+The constructor also parses a raw SGR string.
+It infers the color depth from the sequence, so `cc2` needs no `ansi_type`.
+
+```python
+arr = cc.term_array()
+
+assert arr.dtype == [("char", "<U1"), ("sgr", "<u8"), ("rgb", "u1", (2, 4))]
+assert str(color_chain.fromarray(arr)) == str(cc)
+```
+
+`term_array` exposes the structured `ndarray` behind the chain, and `fromarray` reverses it.
+`fromarray` accepts any `ndarray` of that dtype, so an array built by other means converts to a printable `color_chain`.
+
+#### `img2ansi`
+
+```python
+from chromatic import img2ansi
+
+cc = img2ansi("input.png")
+```
+
+`img2ansi` reads an image and returns a `color_chain`.
+
+```python
+arr = img2ansi("input.png", outarray=True)
+
+assert color_chain.fromarray(arr) == cc
+```
+
+`outarray=True` returns the underlying `ndarray` instead.
+
+#### `ansi2img`
+
+```python
+from chromatic import ansi2img
+
+img = ansi2img(cc)
+img.show()
+```
+
+`ansi2img` renders a `color_chain` back to an image.
+It also accepts a dtype-matching array.
+
+#### `ansify`
+
+```python
+from chromatic import ansify
+
+img = ansify("input.png")
+arr = img.info["ansi_array"]
+```
+
+`ansify` runs both directions in one call, returning the rendered image with the array it rendered from on `Image.info`.
+
+#### Animated images
+
+```python
+frames = img2ansi("input.gif")
+
+assert isinstance(frames, list)
+assert all(isinstance(f, color_chain) for f in frames)
+```
+
+An animated image renders to a `list[color_chain]`, one per frame.
+
+```shell
+chromatic image ansify input.gif --stdout
+```
+
+The [CLI](https://crypt0lith.github.io/chromatic/cli/image/#chromatic-image-ansify) renders and plays one straight to the terminal.
+
+### Installation
+
+Install the package using `pip`:
+
+```shell
+pip install chromatic-python
+```
+
+### Credits
+
+Banner artwork: [main rules by Crasher (2002)](https://16colo.rs/pack/galza-14/CRS-MAIN.ANS)

{chromatic_python-0.9.0 → chromatic_python-0.9.2}/chromatic/__init__.pyi

@@ -3,6 +3,7 @@ __all__ = [
     "Color",
     "ColorNamespace",
     "ColorStr",
+    "DEFAULT_FONT",
     "Fore",
     "SgrFlag",
     "SgrParameter",
@@ -38,10 +39,10 @@ __all__ = [
     "reshape_ansi",
     "rgb2hexstr",
     "rgb2int",
+    "set_default_ansi",
     "sort_glyphs",
     "ttf_extract_codepoints",
     "userfonts",
-    "set_default_ansi",
 ]
 from . import color, data, image
 from ._version import version as __version__
@@ -66,7 +67,7 @@ from .color import (
     rgb2int,
     set_default_ansi,
 )
-from .data import UserFont, register_userfont, userfonts
+from .data import DEFAULT_FONT, UserFont, register_userfont, userfonts
 from .image import (
     ansi2img,
     ansi_quantize,

{chromatic_python-0.9.0 → chromatic_python-0.9.2}/chromatic/__main__.py

@@ -581,7 +581,8 @@ def Parser(prog=None):
 
 
 def parse_args(argv=None):
-    return Parser(os.path.basename((argv or sys.argv)[0])).parse_args(argv)
+    argv = argv or sys.argv
+    return Parser(os.path.basename(argv[0])).parse_args(argv[1:])
 
 
 def _call_from_ns[R](f: abc.Callable[..., R], /, ns, **kwargs) -> R:
@@ -655,10 +656,11 @@ def handle_image(ns):
     params = {}
     if is_anim := arr.ndim == 3:
         params.update(save_all=True)
+    isatty = False
     if hasattr(ns, "dumpfile"):
         from .color.core import color_chain
 
-        if is_anim and ns.dumpfile.isatty():
+        if (isatty := ns.dumpfile.isatty()) and is_anim:
 
             def anim_loop(n: int | None, duration: int | float):
                 from time import sleep
@@ -691,6 +693,11 @@ def handle_image(ns):
             ns.dumpfile.write(f"{cc}\x1b[0m\n".encode())
     if img is None:
         return
+    if not hasattr(ns, "outfile_callback"):
+        show = getattr(ns, "show", None)
+        if show is True or not (show is False or isatty):
+            return img.show()
+        return
     try:
         outpath = ns.outfile_callback(ns, img, **params)
     except Exception as e:

{chromatic_python-0.9.0 → chromatic_python-0.9.2}/chromatic/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.9.0'
-__version_tuple__ = version_tuple = (0, 9, 0)
+__version__ = version = '0.9.2'
+__version_tuple__ = version_tuple = (0, 9, 2)
 
-__commit_id__ = commit_id = 'g17e936a21'
+__commit_id__ = commit_id = 'gbe4e6a5cd'

{chromatic_python-0.9.0 → chromatic_python-0.9.2}/chromatic/color/core.py

@@ -3,6 +3,7 @@ __all__ = [
     "Color",
     "ColorChainDType",
     "ColorStr",
+    "DEFAULT_ANSI",
     "SGR_RESET",
     "SgrFlag",
     "SgrParameter",
@@ -16,6 +17,7 @@ __all__ = [
     "is_vt_enabled",
     "randcolor",
     "rgb2ansi_escape",
+    "set_default_ansi",
 ]
 
 import collections.abc as abc
@@ -1349,17 +1351,10 @@ class ColorStr(str, _IntFloatMixin):
         return self._weak_var_update(sgr=sgr)
 
     def strip_style(self):
-        only_colors = []
-        diff = False
-        for x in self._sgr:
-            if x.is_color():
-                only_colors.append(x)
-            elif not diff:
-                diff = True
-        if not diff:
+        if all(x.is_color() for x in self._sgr):
             return self
-        sgr = self._sgr.copy()
-        sgr[:] = only_colors
+        sgr = SgrSequence()
+        sgr.set_colors(self._sgr.rgb_dict, self.ansi_type)
         return self._weak_var_update(sgr=sgr)
 
     def add_reset(self):

{chromatic_python-0.9.0 → chromatic_python-0.9.2}/chromatic/color/core.pyi

@@ -3,6 +3,7 @@ __all__ = [
     "Color",
     "ColorChainDType",
     "ColorStr",
+    "DEFAULT_ANSI",
     "SGR_RESET",
     "SgrFlag",
     "SgrParameter",
@@ -16,6 +17,7 @@ __all__ = [
     "is_vt_enabled",
     "randcolor",
     "rgb2ansi_escape",
+    "set_default_ansi",
 ]
 
 import collections.abc as abc
@@ -169,8 +171,6 @@ class SgrFlag(enum.IntFlag):
     @property
     def parameters(self) -> list[SgrParameter]: ...
 
-_P2F: tp.Final[dict[int, int]]
-_F2P: tp.Final[dict[int, int]]
 _ANSI16C_I2KV: tp.Final[dict[int, tuple[ColorDictKeys, Int3Tuple]]]
 _ANSI16C_KV2I: tp.Final[dict[tuple[ColorDictKeys, Int3Tuple], int]]
 _ANSI256_B2KEY: tp.Final[dict[L[b"38", b"48"], ColorDictKeys]]

{chromatic_python-0.9.0 → chromatic_python-0.9.2}/chromatic/data/userfont.pyi

@@ -29,17 +29,9 @@ class UserFont:
     def __fspath__(self) -> str: ...
     def to_truetype(self) -> FreeTypeFont: ...
 
-class _TypedDictStruct(tp.NamedTuple):
-    required: frozenset[str]
-    optional: frozenset[str]
-    all_keys: frozenset[str]
-    annotations: MappingProxyType[str, type[tp.Any]]
-
-    @classmethod
-    def from_typeddict(cls, typ: type[tp.TypedDict], /) -> tp.Self: ...
-    def match(self, obj: dict, /) -> bool: ...
-
-def _userfont_dict_struct() -> _TypedDictStruct: ...
+def _userfont_dict_struct() -> (
+    tuple[frozenset[str], frozenset[str], frozenset[str], MappingProxyType[str, tp.Any]]
+): ...
 
 userfonts: tp.Final[MappingProxyType[str, UserFont]]