chromatic-python 0.2.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

chromatic/__init__.py

@@ -3,113 +3,6 @@ try:
 except ImportError:
     __version__ = "0.0.0"
 
-from . import ascii, color, data
-from .ascii import (
-    AnsiImage,
-    ansi2img,
-    ansify,
-    ansi_quantize,
-    ascii2img,
-    ascii_printable,
-    contrast_stretch,
-    cp437_printable,
-    equalize_white_point,
-    get_font_key,
-    get_font_object,
-    img2ansi,
-    img2ascii,
-    read_ans,
-    render_ans,
-    reshape_ansi,
-    to_sgr_array,
-)
-from .ascii._glyph_proc import get_glyph_masks
-from .color import (
-    Back,
-    Color,
-    ColorNamespace,
-    ColorStr,
-    Fore,
-    SgrParameter,
-    Style,
-    ansicolor24Bit,
-    ansicolor4Bit,
-    ansicolor8Bit,
-    colorbytes,
-    named_color,
-)
-from .data import register_user_font
+import lazy_loader as _lazy
 
-__all__ = []
-
-try:
-    import os
-    import sys
-    from functools import lru_cache, wraps
-    from types import ModuleType
-
-    def find_modules(path: str):
-        from setuptools import find_packages
-        from pkgutil import iter_modules
-
-        tree: dict[str, dict | ModuleType] = {
-            __name__: {'__module__': sys.modules[__name__]}
-        }
-        children = set()
-        for pkg in find_packages(path):
-            children.add(pkg)
-            pkg_path = path + '/' + pkg.replace('.', '/')
-            if sys.version_info.major == 2 or (
-                sys.version_info.major == 3 and sys.version_info.minor < 6
-            ):
-                for _, name, ispkg in iter_modules([pkg_path]):
-                    if not ispkg:
-                        children.add(f"{pkg}.{name}")
-            else:
-                for info in iter_modules([pkg_path]):
-                    if not info.ispkg:
-                        children.add(f"{pkg}.{info.name}")
-        for child in children:
-            name = f"{__name__}.{child}"
-            depth = tree
-            for node in name.split('.'):
-                if node not in depth:
-                    depth[node] = {}
-                depth = depth[node]
-            if name in sys.modules:
-                depth['__module__'] = sys.modules[name]
-        return tree
-
-    def publicize_modules(modulename: str, tree: dict[str, dict | ModuleType]):
-        def is_local(obj: object):
-            if isinstance(obj, ModuleType):
-                return obj.__spec__.parent == modulename
-            elif hasattr(obj, '__module__'):
-                return obj.__module__ == modulename
-            return obj is not None
-
-        for name, subtree in tree.items():
-            if name == '__module__' and isinstance(subtree, ModuleType):
-                submodule = subtree
-                init_dir = dir(submodule)
-
-                @wraps(submodule.__dir__)
-                def wrapped():
-                    s = set(
-                        attr
-                        for attr in init_dir
-                        if is_local(getattr(submodule, attr, None))
-                    )
-                    if hasattr(submodule, '__all__'):
-                        s.update(submodule.__all__)
-                    return list(s)
-
-                sys.modules[submodule.__name__].__dir__ = wrapped
-
-            else:
-                publicize_modules(f"{modulename}.{name}", subtree)
-
-    publicize_modules(*find_modules(os.path.split(__file__)[0]).popitem())
-
-finally:
-    del find_modules, publicize_modules
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

chromatic/__init__.pyi

@@ -0,0 +1,74 @@
+__all__ = [
+    'AnsiImage',
+    'Back',
+    'Color',
+    'ColorNamespace',
+    'ColorStr',
+    'Fore',
+    'SgrParameter',
+    'Style',
+    '__version__',
+    'ansi2img',
+    'ansi_quantize',
+    'ansicolor24Bit',
+    'ansicolor4Bit',
+    'ansicolor8Bit',
+    'ansify',
+    'image',
+    'ascii2img',
+    'ascii_printable',
+    'color',
+    'colorbytes',
+    'contrast_stretch',
+    'cp437_printable',
+    'data',
+    'equalize_white_point',
+    'get_font_key',
+    'get_font_object',
+    'get_glyph_masks',
+    'img2ansi',
+    'img2ascii',
+    'named_color',
+    'read_ans',
+    'register_userfont',
+    'render_ans',
+    'reshape_ansi',
+    'to_sgr_array',
+]
+from . import color, data, image
+from ._version import version as __version__
+from .color import (
+    Back,
+    Color,
+    ColorNamespace,
+    ColorStr,
+    Fore,
+    SgrParameter,
+    Style,
+    ansicolor24Bit,
+    ansicolor4Bit,
+    ansicolor8Bit,
+    colorbytes,
+    named_color,
+)
+from .data import register_userfont
+from .image import (
+    AnsiImage,
+    ansi2img,
+    ansi_quantize,
+    ansify,
+    ascii2img,
+    ascii_printable,
+    contrast_stretch,
+    cp437_printable,
+    equalize_white_point,
+    get_font_key,
+    get_font_object,
+    img2ansi,
+    img2ascii,
+    read_ans,
+    render_ans,
+    reshape_ansi,
+    to_sgr_array,
+)
+from .image._glyph_proc import get_glyph_masks

chromatic/_typing.py

@@ -14,12 +14,13 @@ from typing import (
     Concatenate,
     Hashable,
     Iterable,
-    Literal,
+    Literal as L,
     NamedTuple,
     Optional,
     ParamSpec,
     Protocol,
     Sequence,
+    TYPE_CHECKING,
     Type,
     TypeAlias,
     TypeAliasType,
@@ -40,7 +41,8 @@ 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
+if TYPE_CHECKING:
+    from .data import UserFont
 
 _P = ParamSpec('_P')
 _T = TypeVar('_T')
@@ -48,15 +50,11 @@ _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 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 GlyphArray[_SCT: generic] = SquareMatrix[L[24], _SCT]
 type TupleOf2[_T] = tuple[_T, _T]
 type TupleOf3[_T] = tuple[_T, _T, _T]
 
@@ -68,29 +66,41 @@ 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]
+RGBArray: TypeAlias = ShapedNDArray[tuple[int, int, L[3]], uint8]
+RGBPixel: TypeAlias = ShapedNDArray[tuple[L[3]], uint8]
 
 RGBImageLike: TypeAlias = Image | RGBArray
-RGBVectorLike: TypeAlias = Int3Tuple | IntSequence | RGBPixel
-ColorDictKeys = Literal['fg', 'bg']
-Ansi4BitAlias = Literal['4b']
-Ansi8BitAlias = Literal['8b']
-Ansi24BitAlias = Literal['24b']
+RGBVectorLike: TypeAlias = IntSequence | RGBPixel
+ColorDictKeys = L['fg', 'bg']
+Ansi4BitAlias = L['4b']
+Ansi8BitAlias = L['8b']
+Ansi24BitAlias = L['24b']
 AnsiColorAlias = Ansi4BitAlias | Ansi8BitAlias | Ansi24BitAlias
-FontArgType: TypeAlias = FreeTypeFont | UserFont | str | int
+FontArgType: TypeAlias = 'FreeTypeFont | UserFont | str'
+
+
+def eval_annotation(annotation: str, **kwargs) -> Any:
+    globals_ = kwargs.get('globals', {}) | globals()
+    locals_ = kwargs.get('locals', {})
+    try:
+        return subtype(eval(annotation, globals_.copy(), locals_.copy()))
+    except NameError as e:
+        try:
+            import typing
+
+            globals_[e.name] = getattr(typing, e.name)
+            return eval_annotation(annotation, globals=globals_, locals=locals_)
+        except AttributeError:
+            pass
+        raise
 
 
 def type_error_msg(err_obj, *expected, context: str = '', obj_repr=False):
     n_expected = len(expected)
-    name_slots = ['{%d.__qualname__!r}' % n for n in range(n_expected)]
-    if name_slots and n_expected > 1:
+    name_slots = ["{%d.__name__!r}" % n for n in range(n_expected)]
+    if n_expected > 1:
         name_slots[-1] = f"or {name_slots[-1]}"
-    names = (
-        (', ' if n_expected > 2 else ' ')
-        .join([context.strip()] + name_slots)
-        .format(*expected)
-    )
+    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)
@@ -108,14 +118,11 @@ def is_matching_type(value, typ):
     origin, args = deconstruct_type(typ)
     if origin is Union:
         return any(is_matching_type(value, arg) for arg in args)
-    elif origin is Literal:
+    elif origin is L:
         return value in args
     elif isinstance(typ, TypeVar):
         if typ.__constraints__:
-            return any(
-                is_matching_type(value, constraint)
-                for constraint in typ.__constraints__
-            )
+            return any(is_matching_type(value, constraint) for constraint in typ.__constraints__)
         else:
             return True
     elif origin is type:
@@ -173,9 +180,7 @@ def is_matching_typed_dict(__d: dict, typed_dict: type[dict]) -> tuple[bool, str
         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 False, type_error_msg(field, typ, context=f'keyword argument {name!r} of type')
     return True, ''
 
 
@@ -201,20 +206,20 @@ def unionize(__iterable: Iterable[SupportsUnion[_T_contra, _T_co]]) -> _T_co:
 
 _GenericAlias = type(Type[...]) | types.GenericAlias
 _UnionGenericType = type(Union[..., None])
-_LiteralGenericType = type(Literal[''])
+_LiteralGenericType = type(L[''])
 _CallableGenericType = type(Callable[[], ...]) | type(ABC_Callable[[], ...])
 _CallableType = type(Callable) | ABC_Callable
 
 
 class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
+    """Bounded OrderedDict, mimics FIFO behavior of `functools.lru_cache`"""
 
     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__)
+            @wraps(_BoundedDict.__setitem__)
             def _fifo(_, key, value):
                 if maxsize <= len(self):
                     self.popitem(last=True)
@@ -226,9 +231,9 @@ class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
 
 
 _SUBTYPE_CACHE: _BoundedDict[int, ...] = _BoundedDict()
-_ATTR_GETTERS: _BoundedDict[
-    ..., tuple[Callable[[Iterable], NamedTuple], op.attrgetter]
-] = _BoundedDict()
+_ATTR_GETTERS: _BoundedDict[..., tuple[Callable[[Iterable], NamedTuple], op.attrgetter]] = (
+    _BoundedDict()
+)
 
 
 def _unique_attrs(obj) -> Optional['NamedTuple']:
@@ -273,8 +278,7 @@ def _sort_attrs(obj, tp_name, attr_names):
     try:
         sig = inspect.signature(type(obj))
         indices = (
-            dict.fromkeys(field_names, inf)
-            | {p: i for i, p in enumerate(sig.parameters)}
+            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__)
@@ -296,9 +300,7 @@ def _sort_attrs(obj, tp_name, attr_names):
                     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(')')
-                    )
+                    params, _, _ = (s.translate(no_square_parens) for s in params.partition(')'))
                     maybe_sigs.add(params)
                 except StopIteration:
                     break
@@ -306,20 +308,15 @@ def _sort_attrs(obj, tp_name, attr_names):
     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),
+                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)
-        }
+        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)))
-        ]
+        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:
@@ -356,9 +353,7 @@ def subtype[_T](typ: _T) -> _T:
             args_list = list(args)
             if (
                 literals := [
-                    idx
-                    for idx, elem in enumerate(args)
-                    if isinstance(elem, _LiteralGenericType)
+                    idx for idx, elem in enumerate(args) if isinstance(elem, _LiteralGenericType)
                 ]
             ) and len(literals) > 1:
 
@@ -368,7 +363,7 @@ def subtype[_T](typ: _T) -> _T:
                     return getattr(value, '__args__', ())
 
                 start = args[literals.pop(0)]
-                args_list[args_list.index(start)] = Literal[
+                args_list[args_list.index(start)] = L[
                     *start.__args__,
                     *dict.fromkeys(arg for idx in literals for arg in _next_args(idx)),
                 ]

chromatic/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.3'
-__version_tuple__ = version_tuple = (0, 2, 3)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)

chromatic/color/__init__.py

@@ -1,6 +1,3 @@
-from . import core, palette
-from .colorconv import *
-from .core import *
-from .palette import *
+import lazy_loader as _lazy
 
-__all__ = list(set(core.__all__) | set(colorconv.__all__) | set(palette.__all__))
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

chromatic/color/__init__.pyi

@@ -0,0 +1,86 @@
+__all__ = [
+    'ANSI_4BIT_RGB',
+    'Back',
+    'CSI',
+    'Color',
+    'ColorNamespace',
+    'ColorStr',
+    'Fore',
+    'SGR_RESET',
+    'SgrParameter',
+    'SgrSequence',
+    'Style',
+    'ansi_4bit_to_rgb',
+    'ansi_8bit_to_rgb',
+    'ansicolor24Bit',
+    'ansicolor4Bit',
+    'ansicolor8Bit',
+    'color_chain',
+    'colorbytes',
+    'get_ansi_type',
+    'int2rgb',
+    'hexstr2rgb',
+    'hsl2rgb',
+    'hsv2rgb',
+    'is_u24',
+    'lab2rgb',
+    'lab2xyz',
+    'named_color',
+    'nearest_ansi_4bit_rgb',
+    'nearest_ansi_8bit_rgb',
+    'randcolor',
+    'rgb2ansi_escape',
+    'rgb2int',
+    'rgb2hexstr',
+    'rgb2hsl',
+    'rgb2hsv',
+    'rgb2lab',
+    'rgb2xyz',
+    'rgb_diff',
+    'rgb_dispatch',
+    'rgb_to_ansi_8bit',
+    'xyz2lab',
+    'xyz2rgb',
+]
+from . import colorconv, core, iterators, palette
+from .colorconv import (
+    ANSI_4BIT_RGB,
+    ansi_4bit_to_rgb,
+    ansi_8bit_to_rgb,
+    int2rgb,
+    hexstr2rgb,
+    hsl2rgb,
+    hsv2rgb,
+    is_u24,
+    lab2rgb,
+    lab2xyz,
+    nearest_ansi_4bit_rgb,
+    nearest_ansi_8bit_rgb,
+    rgb2int,
+    rgb2hexstr,
+    rgb2hsl,
+    rgb2hsv,
+    rgb2lab,
+    rgb2xyz,
+    rgb_diff,
+    rgb_to_ansi_8bit,
+    xyz2lab,
+    xyz2rgb,
+)
+from .core import (
+    CSI,
+    Color,
+    ColorStr,
+    SGR_RESET,
+    SgrParameter,
+    SgrSequence,
+    ansicolor24Bit,
+    ansicolor4Bit,
+    ansicolor8Bit,
+    color_chain,
+    colorbytes,
+    get_ansi_type,
+    randcolor,
+    rgb2ansi_escape,
+)
+from .palette import Back, ColorNamespace, Fore, Style, named_color, rgb_dispatch