Chore/upgrade coloraide (#240)

* Upgrade coloraide to 1.5

* Update changelog

Author: facelessuser

CHANGES.md

@@ -2,7 +2,7 @@
 
 ## 6.1.0
 
-- **NEW**: Update to ColorAide 1.4.
+- **NEW**: Update to ColorAide 1.5.
 - **FIX**: Fix issue where if a view does not have a syntax it could  
   cause an exception.
 

lib/coloraide/__meta__.py

@@ -192,5 +192,5 @@ def parse_version(ver: str) -> Version:
     return Version(major, minor, micro, release, pre, post, dev)
 
 
-__version_info__ = Version(1, 4, 0, "final")
+__version_info__ = Version(1, 5, 0, "final")
 __version__ = __version_info__._get_canonical()

lib/coloraide/color.py

@@ -15,7 +15,7 @@
 from itertools import zip_longest as zipl
 from .css import parse
 from .types import VectorLike, Vector, ColorInput
-from .spaces import Space, Cylindrical
+from .spaces import Space
 from .spaces.hsv import HSV
 from .spaces.srgb.css import sRGB
 from .spaces.srgb_linear import sRGBLinear
@@ -65,6 +65,8 @@
 class ColorMatch:
     """Color match object."""
 
+    __slots__ = ('color', 'start', 'end')
+
     def __init__(self, color: 'Color', start: int, end: int) -> None:
         """Initialize."""
 
@@ -588,9 +590,8 @@ def chromatic_adaptation(
     ) -> Vector:
         """Chromatic adaptation."""
 
-        try:
-            adapter = cls.CAT_MAP[method if method is not None else cls.CHROMATIC_ADAPTATION]
-        except KeyError:
+        adapter = cls.CAT_MAP.get(method if method is not None else cls.CHROMATIC_ADAPTATION)
+        if not adapter:
             raise ValueError("'{}' is not a supported CAT".format(method))
 
         return adapter.adapt(w1, w2, xyz)
@@ -604,14 +605,7 @@ def clip(self, space: Optional[str] = None) -> 'Color':
 
         # Convert to desired space
         c = self.convert(space, in_place=True)
-
-        # If we are perfectly in gamut, don't waste time clipping.
-        if c.in_gamut(tolerance=0.0):
-            if isinstance(c._space, Cylindrical):
-                name = c._space.hue_name()
-                c.set(name, util.constrain_hue(c[name]))
-        else:
-            gamut.clip_channels(c)
+        gamut.clip_channels(c)
 
         # Adjust "this" color
         return c.convert(orig_space, in_place=True)
@@ -625,60 +619,48 @@ def fit(
     ) -> 'Color':
         """Fit the gamut using the provided method."""
 
+        if method is None:
+            method = self.FIT
+
         # Dedicated clip method.
-        orig_space = self.space()
-        if method == 'clip' or (method is None and self.FIT == "clip"):
+        if method == 'clip':
+
             return self.clip(space)
 
+        orig_space = self.space()
         if space is None:
             space = self.space()
 
-        if method is None:
-            method = self.FIT
-
         # Select appropriate mapping algorithm
-        if method in self.FIT_MAP:
-            func = self.FIT_MAP[method].fit
-        else:
+        mapping = self.FIT_MAP.get(method)
+        if not mapping:
+
             # Unknown fit method
             raise ValueError("'{}' gamut mapping is not currently supported".format(method))
 
         # Convert to desired space
-        c = self.convert(space, in_place=True)
+        self.convert(space, in_place=True)
 
-        # If we are perfectly in gamut, don't waste time fitting, just normalize hues.
-        # If out of gamut, apply mapping/clipping/etc.
-        if c.in_gamut(tolerance=0.0):
-            if isinstance(c._space, Cylindrical):
-                name = c._space.hue_name()
-                c.set(name, util.constrain_hue(c[name]))
-        else:
-            # Doesn't seem to be an easy way that `mypy` can know whether this is the ABC class or not
-            func(c, **kwargs)
+        # Call the appropriate gamut mapping algorithm
+        mapping.fit(self, **kwargs)
 
-        # Adjust "this" color
-        return c.convert(orig_space, in_place=True)
+        # Convert back to the original color space
+        return self.convert(orig_space, in_place=True)
 
     def in_gamut(self, space: Optional[str] = None, *, tolerance: float = util.DEF_FIT_TOLERANCE) -> bool:
         """Check if current color is in gamut."""
 
         if space is None:
             space = self.space()
 
-        # Check gamut in the provided space
-        if space is not None and space != self.space():
-            c = self.convert(space)
-            return c.in_gamut(tolerance=tolerance)
+        # Check if gamut is in the provided space
+        c = self.convert(space) if space is not None and space != self.space() else self
 
         # Check the color space specified for gamut checking.
         # If it proves to be in gamut, we will then test if the current
         # space is constrained properly.
-        if self._space.GAMUT_CHECK is not None:
-            c = self.convert(self._space.GAMUT_CHECK)
-            if not c.in_gamut(tolerance=tolerance):
-                return False
-
-        return gamut.verify(self, tolerance)
+        if c._space.GAMUT_CHECK is not None and not c.convert(c._space.GAMUT_CHECK).in_gamut(tolerance=tolerance):
+            return False
 
     def mask(self, channel: Union[str, Sequence[str]], *, invert: bool = False, in_place: bool = False) -> 'Color':
         """Mask color channels."""
@@ -710,7 +692,11 @@ def mix(
 
         if not self._is_color(color) and not isinstance(color, (str, Mapping)):
             raise TypeError("Unexpected type '{}'".format(type(color)))
-        mixed = self.interpolate([self, color], **interpolate_args)(percent)
+        i = self.interpolate([self, color], **interpolate_args)
+        # Scale really needs to be between 0 and 1 as mix deals in percentages.
+        if i.domain:
+            i.domain = interpolate.normalize_domain(i.domain)
+        mixed = i(percent)
         return self.mutate(mixed) if in_place else mixed
 
     @classmethod
@@ -726,7 +712,11 @@ def steps(
     ) -> List['Color']:
         """Discrete steps."""
 
-        return cls.interpolate(colors, **interpolate_args).steps(steps, max_steps, max_delta_e, delta_e)
+        i = cls.interpolate(colors, **interpolate_args)
+        # Scale really needs to be between 0 and 1 or steps will break
+        if i.domain:
+            i.domain = interpolate.normalize_domain(i.domain)
+        return i.steps(steps, max_steps, max_delta_e, delta_e)
 
     @classmethod
     def interpolate(
@@ -739,6 +729,7 @@ def interpolate(
         hue: str = util.DEF_HUE_ADJ,
         premultiplied: bool = True,
         extrapolate: bool = False,
+        domain: Optional[List[float]] = None,
         method: str = "linear",
         **kwargs: Any
     ) -> Interpolator:
@@ -764,6 +755,7 @@ def interpolate(
             hue=hue,
             premultiplied=premultiplied,
             extrapolate=extrapolate,
+            domain=domain,
             **kwargs
         )
 
@@ -828,10 +820,10 @@ def delta_e(
         if method is None:
             method = self.DELTA_E
 
-        try:
-            return self.DE_MAP[method].distance(self, color, **kwargs)
-        except KeyError:
+        delta = self.DE_MAP.get(method)
+        if not delta:
             raise ValueError("'{}' is not currently a supported distancing algorithm.".format(method))
+        return delta.distance(self, color, **kwargs)
 
     def distance(self, color: ColorInput, *, space: str = "lab") -> float:
         """Delta."""
@@ -860,33 +852,84 @@ def contrast(self, color: ColorInput, method: Optional[str] = None) -> float:
         color = self._handle_color_input(color)
         return contrast.contrast(method, self, color)
 
-    def get(self, name: str) -> float:
+    @overload
+    def get(self, name: str) -> float:  # noqa: D105
+        ...
+
+    @overload
+    def get(self, name: Union[List[str], Tuple[str, ...]]) -> List[float]:  # noqa: D105
+        ...
+
+    def get(self, name: Union[str, List[str], Tuple[str, ...]]) -> Union[float, List[float]]:
         """Get channel."""
 
-        # Handle space.attribute
-        if '.' in name:
-            space, channel = name.split('.', 1)
-            obj = self.convert(space)
-            return obj[channel]
+        # Handle single channel
+        if isinstance(name, str):
+            # Handle space.channel
+            if '.' in name:
+                space, channel = name.split('.', 1)
+                return self.convert(space)[channel]
+            return self[name]
 
-        return self[name]
+        # Handle list of channels
+        else:
+            original_space = current_space = self.space()
+            obj = self
+            values = []
+
+            for n in name:
+                # Handle space.channel
+                space, channel = n.split('.', 1) if '.' in n else (original_space, n)
+                if space != current_space:
+                    obj = self if space == original_space else self.convert(space)
+                    current_space = space
+                values.append(obj[channel])
+            return values
 
     def set(  # noqa: A003
         self,
-        name: str,
-        value: Union[float, Callable[..., float]]
+        name: Union[str, Dict[str, Union[float, Callable[..., float]]]],
+        value: Optional[Union[float, Callable[..., float]]] = None
     ) -> 'Color':
         """Set channel."""
 
-        # Handle space.attribute
-        if '.' in name:
-            space, channel = name.split('.', 1)
-            obj = self.convert(space)
-            obj[channel] = value(obj[channel]) if callable(value) else value
-            return self.update(obj)
+        # Set all the channels in a dictionary.
+        # Sort by name to reduce how many times we convert
+        # when dealing with different color spaces.
+        if value is None:
+            if isinstance(name, str):
+                raise ValueError("Missing the positional 'value' argument for channel '{}'".format(name))
+
+            original_space = current_space = self.space()
+            obj = self.clone()
+
+            for k, v in name.items():
+
+                # Handle space.channel
+                space, channel = k.split('.', 1) if '.' in k else (original_space, k)
+                if space != current_space:
+                    obj.convert(space, in_place=True)
+                    current_space = space
+                obj[channel] = v(obj[channel]) if callable(v) else v
+
+            # Update the original color
+            self.update(obj)
+
+        # Set a single channel value
+        else:
+            if isinstance(name, dict):
+                raise ValueError("A dict of channels and values cannot be used with the positional 'value' parameter")
+
+            # Handle space.channel
+            if '.' in name:
+                space, channel = name.split('.', 1)
+                obj = self.convert(space)
+                obj[channel] = value(obj[channel]) if callable(value) else value
+                return self.update(obj)
+
+            # Handle a function that modifies the value or a direct value
+            self[name] = value(self[name]) if callable(value) else value
 
-        # Handle a function that modifies the value or a direct value
-        self[name] = value(self[name]) if callable(value) else value
         return self
 
 

lib/coloraide/compositing/blend_modes.py

@@ -304,7 +304,7 @@ def apply(self, cb: Vector, cs: Vector) -> Vector:
 def get_blender(blend: str) -> Blend:
     """Get desired blend mode."""
 
-    try:
-        return SUPPORTED[blend]
-    except KeyError:
+    blender = SUPPORTED.get(blend)
+    if not blender:
         raise ValueError("'{}' is not a recognized blend mode".format(blend))
+    return blender

lib/coloraide/compositing/porter_duff.py

@@ -237,7 +237,7 @@ def fb(self) -> float:
 def compositor(name: str) -> Type[PorterDuff]:
     """Get the requested compositor."""
 
-    try:
-        return SUPPORTED[name]
-    except KeyError:
+    composite = SUPPORTED.get(name)
+    if not composite:
         raise ValueError("'{}' compositing is not supported".format(name))
+    return composite

lib/coloraide/contrast/__init__.py

@@ -23,9 +23,8 @@ def contrast(name: Optional[str], color1: 'Color', color2: 'Color', **kwargs: An
     if name is None:
         name = color1.CONTRAST
 
-    try:
-        func = color1.CONTRAST_MAP[name].contrast
-    except KeyError:
+    method = color1.CONTRAST_MAP.get(name)
+    if not method:
         raise ValueError("'{}' contrast method is not supported".format(name))
 
-    return func(color1, color2, **kwargs)
+    return method.contrast(color1, color2, **kwargs)

lib/coloraide/css/parse.py

@@ -142,7 +142,7 @@
         \b(oklch)\(\s*
         (?:
             # Space separated format
-            (?:(?:{strict_percent}|{float}){space}){{2}}{angle}{angle}(?:{slash}(?:{strict_percent}|{float}))?
+            (?:(?:{strict_percent}|{float}){space}){{2}}{angle}(?:{slash}(?:{strict_percent}|{float}))?
         )
         \s*\)
         """.format(**COLOR_PARTS)

lib/coloraide/distance/delta_e_hyab.py

@@ -36,7 +36,7 @@ def distance(self, color: 'Color', sample: 'Color', space: Optional[str] = None,
             raise ValueError("The space '{}' is not a 'lab-ish' color space and cannot use HyAB".format(space))
 
         names = color._space.labish_names()
-        l1, a1, b1 = alg.no_nans([color.get(names[0]), color.get(names[1]), color.get(names[2])])
-        l2, a2, b2 = alg.no_nans([sample.get(names[0]), sample.get(names[1]), sample.get(names[2])])
+        l1, a1, b1 = alg.no_nans(color.get(names))
+        l2, a2, b2 = alg.no_nans(sample.get(names))
 
         return abs(l1 - l2) + math.sqrt((a1 - a2) ** 2 + (b1 - b2) ** 2)

lib/coloraide/filters/__init__.py

@@ -29,9 +29,8 @@ def filters(
 ) -> 'Color':
     """Filter."""
 
-    try:
-        f = color.FILTER_MAP[name]
-    except KeyError:
+    f = color.FILTER_MAP.get(name)
+    if not f:
         raise ValueError("'{}' filter is not supported".format(name))
 
     if space is None:

lib/coloraide/gamut/__init__.py

@@ -3,7 +3,7 @@
 from ..channels import FLG_ANGLE
 from abc import ABCMeta, abstractmethod
 from ..types import Plugin
-from typing import TYPE_CHECKING, Optional, Any
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:  # pragma: no cover
     from ..color import Color
@@ -38,8 +38,8 @@ def verify(color: 'Color', tolerance: float) -> bool:
         if chan.flags & FLG_ANGLE or not chan.bound or alg.is_nan(value):
             continue
 
-        a = chan.low  # type: Optional[float]
-        b = chan.high  # type: Optional[float]
+        a = chan.low
+        b = chan.high
 
         # Check if bounded values are in bounds
         if (a is not None and value < (a - tolerance)) or (b is not None and value > (b + tolerance)):