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

chromatic/__init__.py

@@ -7,6 +7,7 @@ from . import ascii, color, data
 from .ascii import (
     AnsiImage,
     ansi2img,
+    ansify,
     ansi_quantize,
     ascii2img,
     ascii_printable,
@@ -40,3 +41,75 @@ from .color import (
 from .data import register_user_font
 
 __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

chromatic/_typing.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import inspect
+import operator as op
 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,
@@ -48,8 +48,12 @@ _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]
@@ -79,10 +83,14 @@ 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)]
+    name_slots = ['{%d.__qualname__!r}' % n 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)
+    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)
@@ -104,7 +112,10 @@ def is_matching_type(value, typ):
         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:
@@ -162,7 +173,9 @@ 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, ''
 
 
@@ -183,7 +196,7 @@ class SupportsUnion(Protocol[_T_contra, _T_co]):
 
 
 def unionize(__iterable: Iterable[SupportsUnion[_T_contra, _T_co]]) -> _T_co:
-    return reduce(bitwise_or, __iterable)
+    return reduce(op.or_, __iterable)
 
 
 _GenericAlias = type(Type[...]) | types.GenericAlias
@@ -213,9 +226,9 @@ class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
 
 
 _SUBTYPE_CACHE: _BoundedDict[int, ...] = _BoundedDict()
-_ATTR_GETTERS: _BoundedDict[..., tuple[Callable[[Iterable], NamedTuple], attrgetter]] = (
-    _BoundedDict()
-)
+_ATTR_GETTERS: _BoundedDict[
+    ..., tuple[Callable[[Iterable], NamedTuple], op.attrgetter]
+] = _BoundedDict()
 
 
 def _unique_attrs(obj) -> Optional['NamedTuple']:
@@ -247,7 +260,10 @@ def _unique_attrs(obj) -> Optional['NamedTuple']:
         + 'Attrs'
     ).strip('_')
     UniqueAttrs = cast(NamedTuple, namedtuple(tup_name, field_names))
-    _ATTR_GETTERS[tp] = constructor, getter = UniqueAttrs._make, attrgetter(*attr_names)  # noqa
+    _ATTR_GETTERS[tp] = [constructor, getter] = [
+        UniqueAttrs._make,
+        op.attrgetter(*attr_names),  # noqa
+    ]
     return constructor(getter(obj))
 
 
@@ -257,7 +273,8 @@ 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__)
@@ -279,7 +296,9 @@ 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
@@ -287,15 +306,20 @@ 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:
@@ -332,7 +356,9 @@ 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:
 

chromatic/_version.py

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