chromatic-python 0.4.1__tar.gz → 0.5.0__tar.gz

chromatic_python-0.5.0/.gitattributes

@@ -0,0 +1,20 @@
+# python sources
+*.py	text diff=python
+*.pyi	text diff=python
+
+# documents
+*.md	text diff=markdown
+*.txt	text
+
+# graphics
+*.png	binary
+*.jpg	binary
+*.jpeg	binary
+*.ttf	binary
+*.ttc	binary
+
+# serialization
+*.json	text
+*.toml	text
+*.yaml	text
+*.yml	text

chromatic_python-0.5.0/.gitignore

@@ -0,0 +1,28 @@
+# editor temp/backup files
+*.bak
+*.diff
+.idea/
+*.tmp
+.vscode
+
+# compiled source
+*.dll
+*.exe
+*.o
+*.o.d
+*.py[ocd]
+*.so
+*.mod
+
+# python files
+build
+build-*
+dist
+_version.py
+doc/build
+*.egg-info
+venv/
+
+# this project
+userfont.json
+tests/_*

{chromatic_python-0.4.1 → chromatic_python-0.5.0}/PKG-INFO

@@ -1,27 +1,26 @@
 Metadata-Version: 2.4
 Name: chromatic-python
-Version: 0.4.1
+Version: 0.5.0
 Summary: ANSI art image processing and colored terminal text
 Author: crypt0lith
-Project-URL: Homepage, https://github.com/crypt0lith/chromatic
+License-Expression: MIT
+Project-URL: repository, https://github.com/crypt0lith/chromatic.git
 Keywords: ansi,ascii,art,font,image,terminal,parser
-Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.12
+Requires-Python: <4.0,>=3.13
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: numpy<2.6,>=1.25.2
-Requires-Dist: pillow!=11.2.*,<12.0,>=10.1
+Requires-Dist: pillow>=12.2.0
 Requires-Dist: networkx<4.0,>=3.0
 Requires-Dist: scipy<2.0,>=1.11.4
 Requires-Dist: opencv-python
 Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
-Requires-Dist: fonttools
+Requires-Dist: fonttools>=4.60.2
 Requires-Dist: lazy_loader
-Dynamic: license-file
 
 ![image](https://raw.githubusercontent.com/crypt0lith/chromatic/master/banner.png)
 

{chromatic_python-0.4.1 → chromatic_python-0.5.0}/chromatic/_typing.py

@@ -7,8 +7,8 @@ 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 typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Concatenate,
@@ -20,13 +20,12 @@ from typing import (
     ParamSpec,
     Protocol,
     Sequence,
-    TYPE_CHECKING,
     Type,
     TypeAlias,
     TypeAliasType,
+    TypedDict,
     TypeGuard,
     TypeVar,
-    TypedDict,
     Union,
     Unpack,
     cast,
@@ -36,19 +35,17 @@ from typing import (
     runtime_checkable,
 )
 
+from numpy import dtype, float64, generic, ndarray, uint8
+from numpy._typing import NDArray, _ArrayLike
 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
 
 if TYPE_CHECKING:
     from .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]
@@ -180,16 +177,16 @@ def is_matching_type(value, typ):
             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)
+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:
+    if unexpected := d.keys() - expected:
         return False, f"unexpected keyword arguments: {unexpected}"
-    if missing := set(getattr(typed_dict, '__required_keys__', expected)) - __d.keys():
+    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)
+        field = d.get(name)
         if field is None or is_matching_type(field, typ):
             continue
         return False, type_error_msg(
@@ -214,15 +211,14 @@ 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(op.or_, __iterable)
+def unionize(iterable: Iterable[SupportsUnion[_T_contra, _T_co]], /) -> _T_co:
+    return reduce(op.or_, iterable)
 
 
 _GenericAlias = type(Type[...]) | types.GenericAlias
 _UnionGenericType = type(Union[..., None])
 _LiteralGenericType = type(L[''])
 _CallableGenericType = type(Callable[[], ...]) | type(ABC_Callable[[], ...])
-_CallableType = type(Callable) | ABC_Callable
 
 
 class _BoundedDict[_KT, _VT](OrderedDict[_KT, _VT]):
@@ -346,11 +342,12 @@ def _sort_attrs(obj, tp_name, attr_names):
     return attr_names, field_names
 
 
-def subtype[_T](typ: _T) -> _T:
-    type TypeVarDict = dict[TypeVar, ...]
+type TypeVarDict = dict[TypeVar, ...]
 
-    def _serialize(__item: tuple[Any, Hashable]):
-        key, value = __item
+
+def subtype[_T](typ: _T) -> _T:
+    def _serialize(item: tuple[Any, Hashable], /):
+        key, value = item
         return _unique_attrs(key), hash(value)
 
     def _cache_key(tp, tvars: TypeVarDict):

chromatic_python-0.5.0/chromatic/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)
+
+__commit_id__ = commit_id = 'g066855df5'

{chromatic_python-0.4.1 → chromatic_python-0.5.0}/chromatic/color/colorconv.py

@@ -25,6 +25,7 @@ __all__ = [
 
 from functools import lru_cache
 from operator import mul, truediv
+from types import MappingProxyType as mappingproxy
 from typing import Final, Literal, SupportsInt, TypeGuard
 
 import numpy as np
@@ -40,11 +41,11 @@ from .._typing import (
 
 
 @lru_cache
-def _supports_int(typ: type) -> TypeGuard[type[SupportsInt]]:
+def _supports_int(typ: type, /) -> TypeGuard[type[SupportsInt]]:
     return issubclass(typ, SupportsInt)
 
 
-def is_u24(value, *, strict: bool = False):
+def is_u24(value, *, strict: bool = False) -> bool:
     """Check if value is an unsigned 24-bit integer.
 
     Parameters
@@ -60,44 +61,46 @@ def is_u24(value, *, strict: bool = False):
         Raised when `strict=True` and value is not u24
     """
     if _supports_int(value.__class__):
-        if 0 <= int(value) <= 0xFFFFFF:
+        if 0 <= int(value) < (1 << 24):
             return True
         elif not strict:
             return False
     raise ValueError(f"{value!r} is not u24")
 
 
-def hexstr2rgb(__str: str) -> Int3Tuple:
-    n = len(__str)
+def hexstr2rgb(s: str, /) -> Int3Tuple:
+    n = len(s)
     if n % 4 == 0:  # trunc alpha
         n *= 3
         n //= 4
-        __str = __str[:n]
+        s = s[:n]
     if n == 3:  # rgb -> rrggbb
-        __str = ''.join(c * 2 for c in __str)
-    if is_u24(value := int(__str, 16), strict=True):
-        return int2rgb(value)
+        s = ''.join(c * 2 for c in s)
+    x = int(s, 16)
+    if not 0 <= x < (1 << 24):
+        raise ValueError(f"{x:#x} is not u24")
+    return int2rgb(x)
 
 
-def rgb2hexstr(rgb: RGBVectorLike) -> str:
+def rgb2hexstr(rgb: RGBVectorLike, /) -> str:
     return "%02x%02x%02x" % tuple(rgb)
 
 
-def rgb2int(rgb: RGBVectorLike) -> int:
+def rgb2int(rgb: RGBVectorLike, /) -> int:
     r, g, b = map(int, rgb)
     return r << 16 | g << 8 | b
 
 
-def int2rgb(__x: int) -> Int3Tuple:
+def int2rgb(x: int, /) -> Int3Tuple:
     try:
-        return getattr(__x, 'rgb')
+        return getattr(x, 'rgb')
     except AttributeError:
         pass
-    x = int(__x) & 0xFFFFFF
+    x = int(x) & 0xFFFFFF
     return (x >> 16) & 0xFF, (x >> 8) & 0xFF, x & 0xFF
 
 
-def xyz2lab(xyz: FloatSequence) -> Float3Tuple:
+def xyz2lab(xyz: FloatSequence, /) -> Float3Tuple:
     x, y, z = (
         n ** (1 / 3) if n > 0.008856 else (7.787 * n) + (16 / 116)
         for n in map(truediv, xyz, (95.047, 100.0, 108.883))
@@ -108,7 +111,7 @@ def xyz2lab(xyz: FloatSequence) -> Float3Tuple:
     return L, a, b
 
 
-def lab2xyz(lab: FloatSequence) -> Float3Tuple:
+def lab2xyz(lab: FloatSequence, /) -> Float3Tuple:
     L, a, b = lab
     y = (L + 16) / 116
     x = a / 500 + y
@@ -133,19 +136,19 @@ M_RGB2XYZ = np.array(
 M_XYZ2RGB = np.linalg.inv(M_RGB2XYZ)
 
 
-def rgb2xyz(rgb: RGBPixel) -> Float3Tuple:
+def rgb2xyz(rgb: RGBPixel, /) -> Float3Tuple:
     x, y, z = M_RGB2XYZ @ (np.array(rgb, dtype=np.float64) / 255.0)
     return x, y, z
 
 
-def xyz2rgb(xyz: ShapedNDArray[tuple[Literal[3]], np.float64]) -> Int3Tuple:
+def xyz2rgb(xyz: ShapedNDArray[tuple[Literal[3]], np.float64], /) -> Int3Tuple:
     r, g, b = (
         np.clip(M_XYZ2RGB @ np.array(xyz, dtype=np.float64), 0.0, 1.0) * 255.0
     ).astype(int)
     return r, g, b
 
 
-def hsl2rgb(hsl: FloatSequence) -> Int3Tuple:
+def hsl2rgb(hsl: FloatSequence, /) -> Int3Tuple:
     h, s, L = hsl
     h /= 360
     h %= 1
@@ -174,7 +177,7 @@ def hsl2rgb(hsl: FloatSequence) -> Int3Tuple:
     return r, g, b
 
 
-def rgb2hsl(rgb: RGBVectorLike) -> Float3Tuple:
+def rgb2hsl(rgb: RGBVectorLike, /) -> Float3Tuple:
     r, g, b = (x / 255.0 for x in rgb)
     m, _, v = sorted([r, g, b])
     L = (m + v) / 2
@@ -196,7 +199,7 @@ def rgb2hsl(rgb: RGBVectorLike) -> Float3Tuple:
     return (360 * h, s, L)
 
 
-def hsv2rgb(hsv: FloatSequence) -> Int3Tuple:
+def hsv2rgb(hsv: FloatSequence, /) -> Int3Tuple:
     h, s, v = hsv
     c = v * s
     x = c * (1 - abs((h / 60) % 2 - 1))
@@ -220,7 +223,7 @@ def hsv2rgb(hsv: FloatSequence) -> Int3Tuple:
     return r, g, b
 
 
-def rgb2hsv(rgb: RGBVectorLike) -> Float3Tuple:
+def rgb2hsv(rgb: RGBVectorLike, /) -> Float3Tuple:
     r, g, b = (x / 255.0 for x in rgb)
     m, v = sorted([r, g, b])[::2]
     delta = v - m
@@ -239,17 +242,17 @@ def rgb2hsv(rgb: RGBVectorLike) -> Float3Tuple:
     return h, s, v
 
 
-def lab2rgb(lab: FloatSequence) -> Int3Tuple:
+def lab2rgb(lab: FloatSequence, /) -> Int3Tuple:
     xyz = lab2xyz(lab)
     return xyz2rgb(np.array(xyz, dtype=np.float64))
 
 
-def rgb2lab(rgb: RGBVectorLike) -> Float3Tuple:
+def rgb2lab(rgb: RGBVectorLike, /) -> Float3Tuple:
     xyz = rgb2xyz(rgb)
     return xyz2lab(xyz)
 
 
-ANSI_4BIT_RGB: Final[list[Int3Tuple]] = [
+ANSI_4BIT_RGB: Final[tuple[Int3Tuple, ...]] = (
     (0, 0, 0),  # black
     (170, 0, 0),  # red
     (0, 170, 0),  # green
@@ -266,10 +269,10 @@ ANSI_4BIT_RGB: Final[list[Int3Tuple]] = [
     (255, 85, 255),  # bright magenta
     (85, 255, 255),  # bright cyan
     (255, 255, 255),  # bright white
-]
+)
 
 
-def ansi_4bit_to_rgb(value: int):
+def ansi_4bit_to_rgb(value: int, /):
     offset = 0
     if value > 37:
         if value <= 47:
@@ -304,26 +307,26 @@ def _4b_lookup() -> dict[Int3Tuple, Int3Tuple]:
     return table
 
 
-ANSI_4BIT_RGB_MAP = _4b_lookup()
+ANSI_4BIT_RGB_MAP = mappingproxy(_4b_lookup())
 
 
-def _quantize_rgb(rgb: RGBVectorLike):
+def _quantize_rgb(rgb: RGBVectorLike, /):
     r, g, b = rgb
     return min(r >> 3, 0x1F), min(g >> 3, 0x1F), min(b >> 3, 0x1F)
 
 
-def nearest_ansi_4bit_rgb(value: RGBVectorLike) -> Int3Tuple:
+def nearest_ansi_4bit_rgb(value: RGBVectorLike, /) -> Int3Tuple:
     return ANSI_4BIT_RGB_MAP[_quantize_rgb(value)]
 
 
-def nearest_ansi_8bit_rgb(value: RGBVectorLike) -> Int3Tuple:
+def nearest_ansi_8bit_rgb(value: RGBVectorLike, /) -> Int3Tuple:
     try:
         return ansi_8bit_to_rgb(rgb_to_ansi_8bit(value))
     except ValueError:
         raise ValueError(f"invalid RGB value: {value!r}") from None
 
 
-def ansi_8bit_to_rgb(value: int):
+def ansi_8bit_to_rgb(value: int, /):
     if 0 <= value < 16:
         return ANSI_4BIT_RGB[value]
     elif value < 232:
@@ -335,7 +338,7 @@ def ansi_8bit_to_rgb(value: int):
     raise ValueError(f"expected an unsigned 8-bit integer, got {value}")
 
 
-def rgb_to_ansi_8bit(rgb: RGBVectorLike) -> int:
+def rgb_to_ansi_8bit(rgb: RGBVectorLike, /) -> int:
     if len(set(rgb)) == 1:
         c = rgb[0]
         if c < 8:
@@ -347,6 +350,6 @@ def rgb_to_ansi_8bit(rgb: RGBVectorLike) -> int:
     return 16 + (36 * r) + (6 * g) + b
 
 
-def rgb_diff(rgb1: Int3Tuple, rgb2: Int3Tuple) -> Int3Tuple:
+def rgb_diff(rgb1: Int3Tuple, rgb2: Int3Tuple, /) -> Int3Tuple:
     lab1, lab2 = map(rgb2lab, (rgb1, rgb2))
     return lab2rgb([(i + j) / 2 for i, j in zip(lab1, lab2)])