Upgrade to ColorAide 7.0

Author: facelessuser

CHANGES.md

@@ -1,5 +1,9 @@
 # ColorHelper
 
+## 6.6.0
+
+-   **NEW**: Upgrade to ColorAide 7.0.
+
 ## 6.5.1
 
 -   **NEW**: Fix issues related to ColorAide update.

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 - 2025 Isaac Muse
+Copyright (c) 2015 - 2026 Isaac Muse
 
 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

color_helper.sublime-settings

@@ -148,6 +148,9 @@
         // "ColorHelper.lib.coloraide.spaces.zcam.ZCAMJMh",
         // "ColorHelper.lib.coloraide.spaces.hellwig.HellwigJMh",
         // "ColorHelper.lib.coloraide.spaces.hellwig.HellwigHKJMh",
+        // "ColorHelper.lib.coloraide.spaces.scam.sCAMJMh",
+        // "ColorHelper.lib.coloraide.spaces.sucs.sUCS",
+        // "ColorHelper.lib.coloraide.spaces.msh.Msh",
         // "ColorHelper.lib.coloraide.spaces.cmy.CMY",
         // "ColorHelper.lib.coloraide.spaces.cmyk.CMYK",
         // "ColorHelper.lib.coloraide.spaces.din99o.DIN99o",

lib/coloraide/__meta__.py

@@ -1,6 +1,6 @@
 """Meta related things."""
 from __future__ import annotations
-from collections import namedtuple
+from typing import NamedTuple
 import re
 
 RE_VER = re.compile(
@@ -37,7 +37,19 @@
 PRE_REL_MAP = {"a": 'alpha', "b": 'beta', "rc": 'candidate'}
 
 
-class Version(namedtuple("Version", ["major", "minor", "micro", "release", "pre", "post", "dev"])):
+class VersionSpec(NamedTuple):
+    """Version specification."""
+
+    major: int
+    minor: int
+    micro: int
+    release: str
+    pre: int
+    post: int
+    dev: int
+
+
+class Version(VersionSpec):
     """
     Get the version (PEP 440).
 
@@ -77,7 +89,6 @@ class Version(namedtuple("Version", ["major", "minor", "micro", "release", "pre"
     Version(1, 2, 3, ".dev")                     1.2.3.dev0
     Version(1, 2, 3, ".dev", dev=1)              1.2.3.dev1
     ```
-
     """
 
     def __new__(
@@ -193,5 +204,5 @@ def parse_version(ver: str) -> Version:
     return Version(major, minor, micro, release, pre, post, dev)
 
 
-__version_info__ = Version(6, 0, 0, "final")
+__version_info__ = Version(7, 0, 0, "final")
 __version__ = __version_info__._get_canonical()

lib/coloraide/algebra.py

@@ -26,13 +26,12 @@
 import operator
 import functools
 import itertools as it
-from .deprecate import deprecated
 from .types import (
     ArrayLike, MatrixLike, EmptyShape, VectorShape, MatrixShape, TensorShape, ArrayShape, VectorLike,
     TensorLike, Array, Matrix, Tensor, Vector, VectorBool, MatrixBool, TensorBool, MatrixInt, ArrayType, VectorInt,  # noqa: F401
     Shape, DimHints, SupportsFloatOrInt
 )
-from typing import Callable, Sequence, Iterator, Any, Iterable, overload
+from typing import Callable, Sequence, Iterator, Any, Iterable, overload, cast
 
 EPS = sys.float_info.epsilon
 RTOL = 4 * EPS
@@ -43,7 +42,6 @@
 MIN_FLOAT = sys.float_info.min
 
 # Keeping for backwards compatibility
-prod = math.prod
 _all = builtins.all
 _any = builtins.any
 
@@ -86,12 +84,12 @@
 ################################
 # General math
 ################################
-def sign(x: float) -> float:
+def sgn(x: SupportsFloatOrInt) -> SupportsFloatOrInt:
     """Return the sign of a given value."""
 
-    if x and x == x:
-        return x / abs(x)
-    return x
+    if isinstance(x, int):
+        return 1 if x > 0 else -1 if x < 0 else 0
+    return 1.0 if x > 0.0 else -1.0 if x < 0 else x
 
 
 def order(x: float) -> int:
@@ -1118,7 +1116,7 @@ def _cross_pad(a: ArrayLike, s: ArrayShape) -> Array:
     m = acopy(a)
 
     # Initialize indexes so we can properly write our data
-    total = prod(s[:-1])
+    total = math.prod(s[:-1])
     idx = [0] * (len(s) - 1)
 
     for c in range(total):
@@ -1783,8 +1781,8 @@ def multi_dot(arrays: Sequence[ArrayLike]) -> Any:
     # We can easily calculate three with less complexity and in less time. Anything
     # greater than three becomes a headache.
     if count == 3:
-        pa = prod(shapes[0])
-        pc = prod(shapes[2])
+        pa = math.prod(shapes[0])
+        pc = math.prod(shapes[2])
         cost1 = pa * shapes[2][0] + pc * shapes[0][0]
         cost2 = pc * shapes[0][1] + pa * shapes[2][1]  # type: ignore[misc]
         if cost1 < cost2:
@@ -1845,7 +1843,7 @@ def __init__(self, array: ArrayLike | float, old: Shape, new: Shape) -> None:
         elif self.different:
             # Calculate the shape of the data.
             if len(old) > 1:
-                self.amount = prod(old[:-1])
+                self.amount = math.prod(old[:-1])
                 self.length = old[-1]
             else:
                 # Vectors have to be handled a bit special as they only have 1-D
@@ -1856,7 +1854,7 @@ def __init__(self, array: ArrayLike | float, old: Shape, new: Shape) -> None:
             # We need to flip them based on whether the original shape has an even or odd number of
             # dimensions.
             diff = [int(x / y) if y else y for x, y in zip(new, old)]
-            repeat = prod(diff[:-1]) if len(old) > 1 else 1
+            repeat = math.prod(diff[:-1]) if len(old) > 1 else 1
             expand = diff[-1]
             if len(diff) > 1 and diff[-2] > 1:
                 self.repeat = expand
@@ -2110,7 +2108,7 @@ def __init__(self, *arrays: ArrayLike | float) -> None:
         # But shouldn't matter for what we do.
         self.shape = common
         self.ndims = max_dims
-        self.size = prod(common)
+        self.size = math.prod(common)
         self._init()
 
     def _init(self) -> None:
@@ -2378,7 +2376,7 @@ def __call__(
                 # Apply math to two N-D matrices
                 if dims_a == dims_b:
                     empty = (not shape_a or 0 in shape_a) and (not shape_b or 0 in shape_b)
-                    if not empty and prod(shape_a) != prod(shape_b):  # pragma: no cover
+                    if not empty and math.prod(shape_a) != math.prod(shape_b):  # pragma: no cover
                         raise ValueError(f'Shape {shape_a} does not match the data total of {shape_b}')
                     with ArrayBuilder(m, shape_a) as build:
                         for x, y in zip(flatiter(a), flatiter(b)):
@@ -2658,13 +2656,6 @@ def vectorize2(
     raise ValueError("'vectorize2' does not support dimensions greater than 2 or less than 1")
 
 
-@deprecated("'vectorize1' is deprecated, use 'vectorize2(func, doc, params=1)' for the equivalent")
-def vectorize1(pyfunc: Callable[..., Any], doc: str | None = None) -> Callable[..., Any]:  # pragma: no cover
-    """An optimized version of vectorize that is hard coded to broadcast only the first input."""
-
-    return vectorize2(pyfunc, doc, params=1)
-
-
 @overload
 def linspace(start: float, stop: float, num: int = ..., endpoint: bool = ...) -> Vector:
     ...
@@ -2805,6 +2796,38 @@ def isnan(a: TensorLike, *, dims: DimHints = ..., **kwargs: Any) -> TensorBool:
 isnan = vectorize2(math.isnan, doc="Test if a value or values in an array are NaN.", params=1)
 
 
+@overload  # type: ignore[no-overload-impl]
+def sign(a: float, *, dims: DimHints = ..., **kwargs: Any) -> float:
+    ...
+
+
+@overload
+def sign(a: VectorLike, *, dims: DimHints = ..., **kwargs: Any) -> Vector:
+    ...
+
+
+@overload
+def sign(a: MatrixLike, *, dims: DimHints = ..., **kwargs: Any) -> Matrix:
+    ...
+
+
+@overload
+def sign(a: TensorLike, *, dims: DimHints = ..., **kwargs: Any) -> Tensor:
+    ...
+
+
+sign = vectorize2(sgn, doc="Return the sign of a number.", params=1)
+
+
+def prod(a: ArrayLike | float) -> float:
+    """Return the product."""
+
+    l = len(shape(a))
+    if l == 0:
+        return float(math.prod([a]))  # type: ignore[list-item]
+    return float(math.prod(flatiter(a) if l > 1 else a)) # type: ignore[arg-type]
+
+
 def allclose(a: ArrayType, b: ArrayType, **kwargs: Any) -> bool:
     """Test if all are close."""
 
@@ -3120,14 +3143,14 @@ def full(array_shape: int | Shape, fill_value: float | ArrayLike) -> Array | flo
         if not isinstance(fill_value, Sequence):
             return fill_value
         _s = shape(fill_value)
-        if prod(_s) == 1:
+        if math.prod(_s) == 1:
             return ravel(fill_value)[0]
 
     # Normalize `fill_value` to be an array.
     elif not isinstance(fill_value, Sequence):
         m = []  # type: Array
         with ArrayBuilder(m, s) as build:
-            for v in [fill_value] * prod(s):
+            for v in [fill_value] * math.prod(s):
                 next(build).append(v)
         return m
 
@@ -3358,9 +3381,9 @@ def transpose(array: ArrayLike | float) -> float | Array:
     # N x M matrix
     if s and s[0] == 0:
         s = s[1:] + (0,)
-        total = prod(s[:-1])
+        total = math.prod(s[:-1])
     else:
-        total = prod(s)
+        total = math.prod(s)
 
     # Create the array
     m = []  # type: Array
@@ -3455,8 +3478,8 @@ def reshape(array: ArrayLike | float, new_shape: int | Shape) -> float | Array:
     empty = (not new_shape or 0 in new_shape) and (not current_shape or 0 in current_shape)
 
     # Make sure we can actually reshape.
-    total = prod(new_shape) if not empty else prod(new_shape[:-1])
-    if not empty and total != prod(current_shape):
+    total = math.prod(new_shape if not empty else new_shape[:-1])
+    if not empty and total != math.prod(current_shape):
         raise ValueError(f'Shape {new_shape} does not match the data total of {shape(array)}')
 
     # Create the array
@@ -4290,7 +4313,7 @@ def _qr(a: Matrix, m: int, n: int, mode: str = 'reduced') -> Any:
     for k in range(0, m - 1 if not tall else n):
         # Calculate the householder reflections
         norm = math.sqrt(sum([r[i][k] ** 2 for i in range(k, m)]))
-        sig = -sign(r[k][k])
+        sig = -sgn(r[k][k])
         u0 = r[k][k] - sig * norm
         w = [[(r[i][k] / u0) if u0 else 1] for i in range(k, m)]
         w[0][0] = 1
@@ -4479,7 +4502,7 @@ def solve(a: MatrixLike | TensorLike, b: ArrayLike) -> Array:
         p, l, u = lu(a, p_indices=True, _shape=s)
 
         # If determinant is zero, we can't solve. Really small determinant may give bad results.
-        if prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:
+        if math.prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:
             raise ValueError('Matrix is singular')
 
         # Solve for x using forward substitution on U and back substitution on L
@@ -4521,7 +4544,7 @@ def solve(a: MatrixLike | TensorLike, b: ArrayLike) -> Array:
 
                 p, l, u = lu(ma, p_indices=True, _shape=m_shape)
 
-                if prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:  # pragma: no cover
+                if math.prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:  # pragma: no cover
                     raise ValueError('Matrix is singular')
 
                 next(build).append(_back_sub_vector(u, _forward_sub_vector(l, [b[i] for i in p], size), size))  # type: ignore[misc]
@@ -4543,7 +4566,7 @@ def solve(a: MatrixLike | TensorLike, b: ArrayLike) -> Array:
 
             p, l, u = lu(ma, p_indices=True, _shape=s[-2:])  # type: ignore[misc]
 
-            if prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:
+            if math.prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:
                 raise ValueError('Matrix is singular')
 
             bi = [[*mb[i]] for i in p]
@@ -4578,8 +4601,8 @@ def det(array: MatrixLike | TensorLike) -> float | Vector:
         size = s[0]
         p, l, u = lu(array, _shape=s)
         swaps = size - trace(p)
-        sign = (-1) ** (swaps - 1) if swaps else 1
-        dt = sign * prod(l[i][i] * u[i][i] for i in range(size))
+        _sign = (-1) ** (swaps - 1) if swaps else 1
+        dt = _sign * math.prod(l[i][i] * u[i][i] for i in range(size))
         return 0.0 if not dt else dt
     else:
         last = s[-2:]  # type: ignore[misc]
@@ -4625,7 +4648,7 @@ def inv(matrix: MatrixLike | TensorLike) -> Matrix | Tensor:
     # Floating point math will produce very small, non-zero determinants for singular matrices.
     # This occurs with Numpy as well.
     # Don't bother calculating sign as we only care about how close to zero we are.
-    if prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:
+    if math.prod(l[i][i] * u[i][i] for i in range(size)) == 0.0:
         raise ValueError('Matrix is singular')
 
     # Solve for the identity matrix (will give us inverse)
@@ -4722,7 +4745,7 @@ def vstack(arrays: Sequence[ArrayLike | float]) -> Matrix | Tensor:
                 raise ValueError('All the input array dimensions except for the concatenation axis must match exactly')
 
         # Stack the arrays
-        m.extend(reshape(a, (prod(s[:1 - dims]),) + s[1 - dims:-1] + s[-1:]))  # type: ignore[arg-type, misc]
+        m.extend(reshape(a, (math.prod(s[:1 - dims]),) + s[1 - dims:-1] + s[-1:]))  # type: ignore[arg-type, misc]
 
         # Update the last array tracker
         if not last or len(last) > len(s):
@@ -4740,7 +4763,7 @@ def _hstack_extract(a: ArrayLike | float, s: ArrayShape) -> Iterator[Array]:
     """Extract data from the second axis."""
 
     data = flatiter(a)
-    length = prod(s[1:])
+    length = math.prod(s[1:])
 
     for _ in range(s[0]):
         yield [next(data) for _ in range(length)]
@@ -5203,9 +5226,9 @@ def roll(
     if axis is None:
         if not isinstance(shift, int):
             shift = sum(shift)
-        p = prod(s)
-        sgn = sign(shift)
-        shift = int(shift % (p * sgn)) if p and sgn else 0
+        p = math.prod(s)
+        _sign = sgn(shift)
+        shift = shift % (p * _sign) if p and _sign else 0
         flat = ravel(a) if len(s) != 1 else [*a]  # type: ignore[misc]
         sh = -shift
         flat[:] = flat[sh:] + flat[:sh]
@@ -5221,11 +5244,12 @@ def roll(
     new_shift = []  # type: VectorInt
     new_axes = []  # type: VectorInt
     for i, j in broadcast(shift, axes):
+        i, j = cast(int, i), cast(int, j)
         if j < 0:
             j = l + j
-        sgn = sign(i)
-        new_shift.append(int(i % (s[j] * sgn)) if s[j] and sgn else 0)  # type: ignore[call-overload]
-        new_axes.append(j)  # type: ignore[arg-type]
+        _sign = sgn(i)
+        new_shift.append((i % (s[j] * _sign)) if s[j] and _sign else 0)
+        new_axes.append(j)
 
     # Perform the roll across the specified axes
     for idx in ndindex(s[:-1] + (1,)):  # type: ignore[misc]

lib/coloraide/average.py

@@ -40,9 +40,15 @@ def average(
     if cs.is_polar():
         hue_index = cs.hue_index()  # type: ignore[attr-defined]
         is_hwb = isinstance(cs, HWBish)
+        hue_max = cs.channels[hue_index].high
+        to_rad = math.tau / hue_max
+        to_hue = hue_max / math.tau
     else:
         hue_index = -1
         is_hwb = False
+        hue_max = 0.0
+        to_rad = 0.0
+        to_hue = 0.0
     channels = cs.channels
     chan_count = len(channels)
     avgs = [0.0] * chan_count
@@ -104,7 +110,7 @@ def average(
                 counts[i] += 1
                 n = counts[i]
                 if i == hue_index:
-                    rad = math.radians(coord)
+                    rad = coord * to_rad
                     sin += ((math.sin(rad) * wfactor) - sin) / n
                     cos += ((math.cos(rad) * wfactor) - cos) / n
                 else:
@@ -132,8 +138,8 @@ def average(
             if abs(sin) < util.ACHROMATIC_THRESHOLD_SM and abs(cos) < util.ACHROMATIC_THRESHOLD_SM:
                 avgs[i] = math.nan
             else:
-                avg_theta = math.degrees(math.atan2(sin, cos))
-                avgs[i] = (avg_theta + 360) if avg_theta < 0 else avg_theta
+                avg_theta = math.atan2(sin, cos) * to_hue
+                avgs[i] = (avg_theta + hue_max) if avg_theta < 0 else avg_theta
         else:
             avgs[i] /= factor