chromatic-python 0.1.1__tar.gz → 0.2.1__tar.gz

chromatic_python-0.2.1/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: chromatic-python
+Version: 0.2.1
+Summary: ANSI art image processing and colored terminal text
+Author: crypt0lith
+License: 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.
+Project-URL: Homepage, https://github.com/crypt0lith/chromatic
+Keywords: ansi,ascii,art,font,image,terminal,parser
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fonttools~=4.51.0
+Requires-Dist: networkx~=3.4.2
+Requires-Dist: numpy~=2.1.1
+Requires-Dist: opencv-python~=4.10.0.84
+Requires-Dist: pillow~=10.4.0
+Requires-Dist: scikit-image~=0.25.0rc1
+Requires-Dist: scikit-learn~=1.5.2
+Requires-Dist: scipy~=1.14.1
+Dynamic: license-file
+
+![image](/logo/logo.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/)
+
+Chromatic is a library for processing and transforming ANSI escape sequences (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 which enables precise low-level control over ANSI-escaped strings through a convenient interface.
+- [colorama](https://github.com/tartley/colorama/)-style wrappers (`Fore`, `Back`, `Style`).
+- Parametrization of ANSI color bit formats, allowing arbitrary conversion between 16-color, 256-color, and true-color (RGB) colorspace on any object implementing a `colorbytes` buffer.
+- Et Cetera 😲
+
+### Usage
+#### ColorStr
+```python
+from chromatic import ColorStr
+
+base_str = 'hello world'
+
+red_fg = ColorStr(base_str, 0xFF0000)
+
+assert red_fg.base_str == base_str
+assert red_fg.rgb_dict == {'fg': (0xFF, 0, 0)}
+assert red_fg.ansi == b'\x1b[38;5;196m'
+```
+
+`ColorStr` can handle different signatures for `color_spec`:
+```python
+from chromatic import ColorStr
+
+assert all(
+	ColorStr('*', cs) == ColorStr('*', 0xFF0000)
+    for cs in [b'\x1b[38;5;196m', b'\xff\x00\x00', (0xFF, 0, 0), {'fg': 0xFF0000}]
+)
+```
+
+The ANSI color format can be given as an argument, or returned by `ColorStr.as_ansi_type()` as a new instance.
+```python
+from chromatic import ColorStr, ansicolor24Bit, ansicolor4Bit
+
+truecolor = ColorStr('*', 0xFF0000, ansi_type=ansicolor24Bit)
+a_16color = truecolor.as_ansi_type(ansicolor4Bit)
+
+# each ansi color format has an alias that can be used in place of the type object
+assert a_16color == truecolor.as_ansi_type('4b')
+
+assert truecolor.ansi_format is ansicolor24Bit and truecolor.ansi == b'\x1b[38;2;255;0;0m'
+assert a_16color.ansi_format is ansicolor4Bit and a_16color.ansi == b'\x1b[31m'
+```
+
+Adding and removing specific ANSI codes from the escape sequence:
+```python
+import chromatic as cm
+
+boring_str = cm.ColorStr('hello world')
+
+assert boring_str.ansi == b''
+
+bold_str = boring_str + cm.SgrParameter.BOLD
+assert bold_str.ansi == b'\x1b[1m'
+
+# use ColorStr.update_sgr() to remove and add SGR values
+unbold_str = bold_str.update_sgr(cm.SgrParameter.BOLD)
+assert unbold_str == boring_str
+assert bold_str == unbold_str.update_sgr(cm.SgrParameter.BOLD)
+```
+
+#### Image-to-ANSI conversion
+
+Converting an image into an array of ANSI-escaped characters, then rendering the ANSI array as another image:
+```python
+from chromatic.color import ansicolor4Bit
+from chromatic.ascii import ansi2img, img2ansi
+from chromatic.data import UserFont, butterfly
+
+input_img = butterfly()
+
+font = UserFont.IBM_VGA_437_8X16
+
+# by default, `char_set` would be sorted based on the relative weight of glyphs in the font
+# but because `sort_glyphs` is set to False, `char_set` will be directly mapped to the image brightness
+#            | <- index 0 is the 'darkest'
+char_set = r"'·,•-_→+<>ⁿ*%⌂7√Iï∞πbz£9yîU{}1αHSw♥æ?GX╕╒éà⌡MF╝╩ΘûǃQ½☻Ŷ┤▄╪║▒█"
+#                                            index -1 is the 'brightest' -> |
+
+ansi_array = img2ansi(input_img, font, sort_glyphs=False, char_set=char_set, ansi_type=ansicolor4Bit, factor=200)
+
+# ansi2img() returns a PIL.Image.Image object
+ansi_img = ansi2img(ansi_array, font, font_size=16)
+ansi_img.show()
+```
+
+### Installation
+Install the package using `pip`:
+```bash
+pip install chromatic-python
+```

chromatic_python-0.2.1/README.md

@@ -0,0 +1,102 @@
+![image](/logo/logo.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/)
+
+Chromatic is a library for processing and transforming ANSI escape sequences (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 which enables precise low-level control over ANSI-escaped strings through a convenient interface.
+- [colorama](https://github.com/tartley/colorama/)-style wrappers (`Fore`, `Back`, `Style`).
+- Parametrization of ANSI color bit formats, allowing arbitrary conversion between 16-color, 256-color, and true-color (RGB) colorspace on any object implementing a `colorbytes` buffer.
+- Et Cetera 😲
+
+### Usage
+#### ColorStr
+```python
+from chromatic import ColorStr
+
+base_str = 'hello world'
+
+red_fg = ColorStr(base_str, 0xFF0000)
+
+assert red_fg.base_str == base_str
+assert red_fg.rgb_dict == {'fg': (0xFF, 0, 0)}
+assert red_fg.ansi == b'\x1b[38;5;196m'
+```
+
+`ColorStr` can handle different signatures for `color_spec`:
+```python
+from chromatic import ColorStr
+
+assert all(
+	ColorStr('*', cs) == ColorStr('*', 0xFF0000)
+    for cs in [b'\x1b[38;5;196m', b'\xff\x00\x00', (0xFF, 0, 0), {'fg': 0xFF0000}]
+)
+```
+
+The ANSI color format can be given as an argument, or returned by `ColorStr.as_ansi_type()` as a new instance.
+```python
+from chromatic import ColorStr, ansicolor24Bit, ansicolor4Bit
+
+truecolor = ColorStr('*', 0xFF0000, ansi_type=ansicolor24Bit)
+a_16color = truecolor.as_ansi_type(ansicolor4Bit)
+
+# each ansi color format has an alias that can be used in place of the type object
+assert a_16color == truecolor.as_ansi_type('4b')
+
+assert truecolor.ansi_format is ansicolor24Bit and truecolor.ansi == b'\x1b[38;2;255;0;0m'
+assert a_16color.ansi_format is ansicolor4Bit and a_16color.ansi == b'\x1b[31m'
+```
+
+Adding and removing specific ANSI codes from the escape sequence:
+```python
+import chromatic as cm
+
+boring_str = cm.ColorStr('hello world')
+
+assert boring_str.ansi == b''
+
+bold_str = boring_str + cm.SgrParameter.BOLD
+assert bold_str.ansi == b'\x1b[1m'
+
+# use ColorStr.update_sgr() to remove and add SGR values
+unbold_str = bold_str.update_sgr(cm.SgrParameter.BOLD)
+assert unbold_str == boring_str
+assert bold_str == unbold_str.update_sgr(cm.SgrParameter.BOLD)
+```
+
+#### Image-to-ANSI conversion
+
+Converting an image into an array of ANSI-escaped characters, then rendering the ANSI array as another image:
+```python
+from chromatic.color import ansicolor4Bit
+from chromatic.ascii import ansi2img, img2ansi
+from chromatic.data import UserFont, butterfly
+
+input_img = butterfly()
+
+font = UserFont.IBM_VGA_437_8X16
+
+# by default, `char_set` would be sorted based on the relative weight of glyphs in the font
+# but because `sort_glyphs` is set to False, `char_set` will be directly mapped to the image brightness
+#            | <- index 0 is the 'darkest'
+char_set = r"'·,•-_→+<>ⁿ*%⌂7√Iï∞πbz£9yîU{}1αHSw♥æ?GX╕╒éà⌡MF╝╩ΘûǃQ½☻Ŷ┤▄╪║▒█"
+#                                            index -1 is the 'brightest' -> |
+
+ansi_array = img2ansi(input_img, font, sort_glyphs=False, char_set=char_set, ansi_type=ansicolor4Bit, factor=200)
+
+# ansi2img() returns a PIL.Image.Image object
+ansi_img = ansi2img(ansi_array, font, font_size=16)
+ansi_img.show()
+```
+
+### Installation
+Install the package using `pip`:
+```bash
+pip install chromatic-python
+```

{chromatic_python-0.1.1 → chromatic_python-0.2.1}/chromatic/__init__.py

@@ -5,6 +5,7 @@ except ImportError:
 
 from . import ascii, color, data
 from .ascii import (
+    AnsiImage,
     ansi2img,
     ansi_quantize,
     ascii2img,
@@ -23,16 +24,18 @@ from .ascii import (
 )
 from .ascii._glyph_proc import get_glyph_masks
 from .color import (
-    ansicolor24Bit,
-    ansicolor4Bit,
-    ansicolor8Bit,
     Back,
     Color,
-    colorbytes,
+    ColorNamespace,
     ColorStr,
     Fore,
     SgrParameter,
     Style,
+    ansicolor24Bit,
+    ansicolor4Bit,
+    ansicolor8Bit,
+    colorbytes,
+    named_color,
 )
 from .data import register_user_font
 

chromatic_python-0.2.1/chromatic/_typing.py

@@ -0,0 +1,399 @@
+from __future__ import annotations
+
+import inspect
+import re
+import types
+from collections import OrderedDict, namedtuple
+from collections.abc import Callable as ABC_Callable
+from functools import reduce, wraps
+from numbers import Number
+from operator import attrgetter, or_ as bitwise_or
+from typing import (
+    Any,
+    Callable,
+    Concatenate,
+    Hashable,
+    Iterable,
+    Literal,
+    NamedTuple,
+    Optional,
+    ParamSpec,
+    Protocol,
+    Sequence,
+    Type,
+    TypeAlias,
+    TypeAliasType,
+    TypeGuard,
+    TypeVar,
+    TypedDict,
+    Union,
+    Unpack,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+    runtime_checkable,
+)
+
+from PIL.Image import Image
+from PIL.ImageFont import FreeTypeFont
+from numpy import dtype, float64, generic, ndarray, number, uint8
+from numpy._typing import NDArray, _ArrayLike
+
+from chromatic.data import UserFont
+
+_P = ParamSpec('_P')
+_T = TypeVar('_T')
+_T_co = TypeVar('_T_co', covariant=True)
+_T_contra = TypeVar('_T_contra', contravariant=True)
+_AnyNumber_co = TypeVar('_AnyNumber_co', number, Number, covariant=True)
+
+type ArrayReducerFunc[_SCT: generic] = Callable[Concatenate[_ArrayLike[_SCT], _P], NDArray[_SCT]]
+type ShapedNDArray[_Shape: tuple[int, ...], _SCT: generic] = ndarray[_Shape, dtype[_SCT]]
+type MatrixLike[_SCT: generic] = ShapedNDArray[TupleOf2[int], _SCT]
+type SquareMatrix[_I: int, _SCT: generic] = ShapedNDArray[TupleOf2[_I], _SCT]
+type GlyphArray[_SCT: generic] = SquareMatrix[Literal[24], _SCT]
+type TupleOf2[_T] = tuple[_T, _T]
+type TupleOf3[_T] = tuple[_T, _T, _T]
+
+Float3Tuple: TypeAlias = TupleOf3[float]
+Int3Tuple: TypeAlias = TupleOf3[int]
+FloatSequence: TypeAlias = Sequence[float]
+IntSequence: TypeAlias = Sequence[int]
+GlyphBitmask: TypeAlias = GlyphArray[bool]
+Bitmask: TypeAlias = MatrixLike[bool]
+GreyscaleGlyphArray: TypeAlias = GlyphArray[float64]
+GreyscaleArray: TypeAlias = MatrixLike[float64]
+RGBArray: TypeAlias = ShapedNDArray[tuple[int, int, Literal[3]], uint8]
+RGBPixel: TypeAlias = ShapedNDArray[tuple[Literal[3]], uint8]
+
+RGBImageLike: TypeAlias = Image | RGBArray
+RGBVectorLike: TypeAlias = Int3Tuple | IntSequence | RGBPixel
+ColorDictKeys = Literal['fg', 'bg']
+Ansi4BitAlias = Literal['4b']
+Ansi8BitAlias = Literal['8b']
+Ansi24BitAlias = Literal['24b']
+AnsiColorAlias = Ansi4BitAlias | Ansi8BitAlias | Ansi24BitAlias
+FontArgType: TypeAlias = FreeTypeFont | UserFont | str | int
+
+
+def type_error_msg(err_obj, *expected, context: str = '', obj_repr=False):
+    n_expected = len(expected)
+    name_slots = [f"{{{n}.__qualname__!r}}" for n in range(n_expected)]
+    if name_slots and n_expected > 1:
+        name_slots[-1] = f"or {name_slots[-1]}"
+    names = (', ' if n_expected > 2 else ' ').join([context.strip()] + name_slots).format(*expected)
+    if not obj_repr:
+        if not isinstance(err_obj, type):
+            err_obj = type(err_obj)
+        oops = repr(err_obj.__qualname__)
+    elif not isinstance(err_obj, str):
+        oops = repr(err_obj)
+    else:
+        oops = err_obj
+    return f"expected {names}, got {oops} instead"
+
+
+def is_matching_type(value, typ):
+    if typ is Any:
+        return True
+    origin, args = deconstruct_type(typ)
+    if origin is Union:
+        return any(is_matching_type(value, arg) for arg in args)
+    elif origin is Literal:
+        return value in args
+    elif isinstance(typ, TypeVar):
+        if typ.__constraints__:
+            return any(is_matching_type(value, constraint) for constraint in typ.__constraints__)
+        else:
+            return True
+    elif origin is type:
+        if not isinstance(value, type):
+            return False
+        target_type = args[0]
+        target_origin = get_origin(target_type)
+        target_args = get_args(target_type)
+        if target_origin is Union:
+            return any(issubclass(value, t) for t in target_args)
+        else:
+            return issubclass(value, target_type)
+    elif origin is Callable:
+        return is_matching_callable(value, typ)
+    elif origin is list:
+        if not isinstance(value, list):
+            return False
+        if not args:
+            return True
+        return all(is_matching_type(item, args[0]) for item in value)
+    elif origin is dict:
+        if not isinstance(value, dict):
+            return False
+        if not args:
+            return True
+        key_type, val_type = args
+        return all(
+            is_matching_type(k, key_type) and is_matching_type(v, val_type)
+            for k, v in value.items()
+        )
+    elif origin is tuple:
+        if not isinstance(value, tuple):
+            return False
+        if len(args) == 2 and args[1] is ...:
+            return all(is_matching_type(item, args[0]) for item in value)
+        if len(value) != len(args):
+            return False
+        return all(is_matching_type(v, t) for v, t in zip(value, args))
+    else:
+        try:
+            return isinstance(value, typ)
+        except TypeError:
+            return False
+
+
+def is_matching_typed_dict(__d: dict, typed_dict: type[dict]) -> tuple[bool, str]:
+    if TypedDict not in getattr(__d, '__orig_bases__', ()):
+        return False, type_error_msg(__d, dict)
+    expected = get_type_hints(typed_dict)
+    if unexpected := __d.keys() - expected:
+        return False, f"unexpected keyword arguments: {unexpected}"
+    if missing := set(getattr(typed_dict, '__required_keys__', expected)) - __d.keys():
+        return False, f"missing required keys: {missing}"
+    for name, typ in expected.items():
+        field = __d.get(name)
+        if field is None or is_matching_type(field, typ):
+            continue
+        return False, type_error_msg(field, typ, context=f'keyword argument {name!r} of type')
+    return True, ''
+
+
+def is_matching_callable(value, expected_type):
+    return callable(value) and value is expected_type
+
+
+def deconstruct_type(tp):
+    origin = get_origin(tp) or tp
+    args = get_args(tp)
+    return origin, args
+
+
+@runtime_checkable
+class SupportsUnion(Protocol[_T_contra, _T_co]):
+
+    def __or__(self, x: _T_contra, /) -> _T_co: ...
+
+
+def unionize(__iterable: Iterable[SupportsUnion[_T_contra, _T_co]]) -> _T_co:
+    return reduce(bitwise_or, __iterable)
+
+
+_GenericAlias = type(Type[...]) | types.GenericAlias
+_UnionGenericType = type(Union[..., None])
+_LiteralGenericType = type(Literal[''])
+_CallableGenericType = type(Callable[[], ...]) | type(ABC_Callable[[], ...])
+_CallableType = type(Callable) | ABC_Callable
+
+
+class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
+
+    def __init__(self, *, maxsize: Optional[int] = 128):
+        """Bounded OrderedDict, mimics FIFO behavior of `functools.lru_cache`"""
+        super().__init__()
+        if maxsize is not None:
+            maxsize = max(maxsize, 0)
+
+            @wraps(self.__setitem__)
+            def _fifo(_, key, value):
+                if maxsize <= len(self):
+                    self.popitem(last=True)
+                super(_BoundedDict, self).__setitem__(key, value)
+
+            self.__setitem__ = _fifo
+
+    __repr__ = dict.__repr__
+
+
+_SUBTYPE_CACHE: _BoundedDict[int, ...] = _BoundedDict()
+_ATTR_GETTERS: _BoundedDict[..., tuple[Callable[[Iterable], NamedTuple], attrgetter]] = (
+    _BoundedDict()
+)
+
+
+def _unique_attrs(obj) -> Optional['NamedTuple']:
+    tp = type(obj)
+    tp_name: str = tp.__name__
+    if tp is type:
+        return
+    elif tp in _ATTR_GETTERS:
+        constructor, getter = _ATTR_GETTERS[tp]
+        return constructor(getter(obj))
+    ignored_attrs = frozenset({'__module__', '__slots__'})
+    attr_names = sorted(
+        s
+        for t in tp.mro()[:-1]
+        for s in set(dir(t)).difference(ignored_attrs, *map(dir, t.mro()[1:]))
+        if not callable(getattr(tp, s, None))
+    )
+    if '__dict__' in attr_names:
+        attr_names = sorted(cast(dict[str, ...], obj.__dict__).keys() - ignored_attrs)
+    if not attr_names:
+        return
+    attr_names, field_names = _sort_attrs(obj, tp_name, attr_names)
+    tup_name = (
+        re.sub(
+            r'\b[a-z0-9_]+\b',
+            lambda m: ''.join(s.capitalize() for s in m.group(0).split('_')),
+            tp_name.strip(),
+        )
+        + 'Attrs'
+    ).strip('_')
+    UniqueAttrs = cast(NamedTuple, namedtuple(tup_name, field_names))
+    _ATTR_GETTERS[tp] = constructor, getter = UniqueAttrs._make, attrgetter(*attr_names)  # noqa
+    return constructor(getter(obj))
+
+
+def _sort_attrs(obj, tp_name, attr_names):
+    field_names = [name.strip('_') for name in attr_names]
+    inf = float('inf')
+    try:
+        sig = inspect.signature(type(obj))
+        indices = (
+            dict.fromkeys(field_names, inf) | {p: i for i, p in enumerate(sig.parameters)}
+        ).values()
+        for names in (attr_names, field_names):
+            names.sort(key=dict(zip(names, indices)).__getitem__)
+        return attr_names, field_names
+    except ValueError:
+        maybe_sigs: set[str | None] = set()
+        text_signature = '__text_signature__'
+        if text_signature in attr_names:
+            attr_names.remove(text_signature)
+            field_names.remove(text_signature.strip('_'))
+            maybe_sigs.add(getattr(obj, text_signature, None))
+        elif doc := getattr(obj, '__doc__', None):
+            lines = iter(inspect.cleandoc(doc).splitlines(keepends=True))
+            no_square_parens = {ord(c): None for c in '[]'}
+            sig_start = tp_name + '('
+            while True:
+                try:
+                    line = next(lines)
+                    while sig_start not in line:
+                        line = next(lines)
+                    _, _, params = line.partition(sig_start)
+                    params, _, _ = (s.translate(no_square_parens) for s in params.partition(')'))
+                    maybe_sigs.add(params)
+                except StopIteration:
+                    break
+    maybe_sigs.discard(None)
+    if maybe_sigs:
+        if len(maybe_sigs) > 1:
+            sig = max(
+                maybe_sigs, key=lambda s: sum(1 for sub in s.split(', ') if sub in field_names)
+            )
+        else:
+            sig = maybe_sigs.pop()
+        positions = {x: i for i, x in enumerate(sig.split(', ')) if x}
+        sorted_field_names = sorted(field_names, key=lambda k: positions.get(k, inf))
+        transitions = {idx: sorted_field_names.index(x) for idx, x in enumerate(field_names)}
+        field_names = sorted_field_names
+        attr_names = [attr_names[k] for k in map(transitions.__getitem__, range(len(attr_names)))]
+    for Names in (attr_names, field_names):
+        name_attr = next((s for s in Names if s.strip('_') == 'name'), None)
+        if name_attr is not None:
+            Names.sort(key=name_attr.__eq__, reverse=True)
+    return attr_names, field_names
+
+
+def subtype[_T](typ: _T) -> _T:
+    type TypeVarDict = dict[TypeVar, ...]
+
+    def _serialize(__item: tuple[Any, Hashable]):
+        key, value = __item
+        return _unique_attrs(key), hash(value)
+
+    def _cache_key(tp, tvars: TypeVarDict):
+        if tvars:
+            value = tp, *sorted(tvars.items(), key=_serialize)
+        else:
+            value = tp
+        return value
+
+    def _inner(tp: ..., tvars: TypeVarDict):
+        key = _cache_key(tp, tvars)
+        recursive = lambda x: _inner(x, tvars)
+        try:
+            if key in _SUBTYPE_CACHE:
+                return _SUBTYPE_CACHE[key]
+            elif tp in tvars:
+                return tvars[tp]
+        except TypeError:
+            pass
+        if isinstance(tp, (_UnionGenericType, types.UnionType)):
+            args = tp.__args__
+            args_list = list(args)
+            if (
+                literals := [
+                    idx for idx, elem in enumerate(args) if isinstance(elem, _LiteralGenericType)
+                ]
+            ) and len(literals) > 1:
+
+                def _next_args(__index: int):
+                    idx = args_list.index(args[__index])
+                    value = args_list.pop(idx)
+                    return getattr(value, '__args__', ())
+
+                start = args[literals.pop(0)]
+                args_list[args_list.index(start)] = Literal[
+                    *start.__args__,
+                    *dict.fromkeys(arg for idx in literals for arg in _next_args(idx)),
+                ]
+            try:
+                return unionize(map(recursive, args_list))
+            except TypeError:
+                return Union[*map(recursive, args_list)]
+        elif isinstance(tp, TypeAliasType):
+            result = recursive(tp.__value__)
+        elif isinstance(tp, _CallableGenericType):
+            ts, rtype = get_args(tp)
+            if isinstance(ts, list):
+                ts = list(map(recursive, ts))
+            result = ABC_Callable[ts, recursive(rtype)]
+        elif isinstance(tp, _GenericAlias):
+            origin, args = cast(tuple[types.GenericAlias, tuple], deconstruct_type(tp))
+            if origin_params := dict(zip(getattr(origin, '__parameters__', ()), args)):
+                if arg_match := origin_params.keys() & tvars:
+                    _union = unionize(
+                        origin[*map(f, arg_match)]
+                        for f in (tvars.__getitem__, origin_params.__getitem__)
+                    )
+                    key = _cache_key(_union, {})
+                    result = _SUBTYPE_CACHE[key] = _inner(_union, {})
+                    return result
+                for param, arg in origin_params.items():
+                    tvars[param] = recursive(arg)
+            if isinstance(origin, TypeAliasType):
+                result = recursive(origin)
+            elif (
+                isinstance(origin, type)
+                and issubclass(origin, tuple)
+                and len(args) == 2
+                and args[-1] is Ellipsis
+            ):
+                result = origin[recursive(args[0]), ...]
+            else:
+                try:
+                    result = origin[*map(recursive, args)]
+                except TypeError:
+                    if origin is Unpack or origin is TypeGuard:
+                        result = origin[recursive(args[0])]
+                    else:
+                        raise
+        elif tp is Ellipsis:
+            return Any
+        elif tp is None or tp is types.NoneType:
+            return None
+        else:
+            return tp
+        _SUBTYPE_CACHE[key] = result
+        return result
+
+    return _inner(typ, {})

chromatic_python-0.2.1/chromatic/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)