Upgrade to use coloraide 2.0.x (#247)

Author: facelessuser

ch_tool_contrast.py

@@ -121,7 +121,7 @@ def evaluate(base, string):
             colors.append(second.fit('srgb'))
             if ratio:
                 if first[-1] < 1.0:
-                    first = first.compose(second, space="srgb")
+                    first = first.compose(second, space="srgb", out_space=first.space())
                 hwb_fg = first.convert('hwb').clip()
                 hwb_bg = second.convert('hwb').clip()
                 first.update(hwb_fg)
@@ -140,10 +140,10 @@ def evaluate(base, string):
 
             if first[-1] < 1.0:
                 # Contrasted with current color
-                colors.append(first.compose(second, space="srgb"))
+                colors.append(first.compose(second, space="srgb", out_space=first.space()))
                 # Contrasted with the two extremes min and max
-                colors.append(first.compose("white", space="srgb"))
-                colors.append(first.compose("black", space="srgb"))
+                colors.append(first.compose("white", space="srgb", out_space=first.space()))
+                colors.append(first.compose("black", space="srgb", out_space=first.space()))
             else:
                 colors.append(first)
     except Exception as e:

ch_util.py

@@ -11,9 +11,38 @@
 import base64
 import importlib
 from .lib.coloraide import Color as Base
-from .lib.coloraide.css.parse import RE_COLOR_MATCH
 from .lib.coloraide import __version_info__ as coloraide_version
 import functools
+import re
+
+COLOR_PARTS = {
+    "strict_percent": r"(?:[+\-]?(?:[0-9]*\.)?[0-9]+(?:e[-+]?[0-9]+)?%)",
+    "strict_float": r"(?:[+\-]?(?:[0-9]*\.)?[0-9]+(?:e[-+]?[0-9]+)?)",
+    "strict_angle": r"(?:[+\-]?(?:[0-9]*\.)?[0-9]+(?:e[-+]?[0-9]+)?(?:deg|rad|turn|grad)?)",
+    "percent": r"(?:[+\-]?(?:[0-9]*\.)?[0-9]+(?:e[-+]?[0-9]+)?%|none)",
+    "float": r"(?:[+\-]?(?:[0-9]*\.)?[0-9]+(?:e[-+]?[0-9]+)?|none)",
+    "angle": r"(?:[+\-]?(?:[0-9]*\.)?[0-9]+(?:e[-+]?[0-9]+)?(?:deg|rad|turn|grad)?|none)",
+    "space": r"\s+",
+    "loose_space": r"\s*",
+    "comma": r"\s*,\s*",
+    "slash": r"\s*/\s*",
+    "sep": r"(?:\s*,\s*|\s+)",
+    "asep": r"(?:\s*[,/]\s*|\s+)",
+    "hex": r"[a-f0-9]"
+}
+
+
+# Allow 15 channels maximum. This should be able to handle any colors we throw at it.
+RE_COLOR_MATCH = re.compile(
+    r"""(?xi)
+    color\(\s*
+    (-{{0,2}}[a-z][-a-z0-9_]*)(?=\s)
+    ((?:{loose_space}(?:{strict_percent}|{float})){{1,15}}(?:{slash}(?:{strict_percent}|{float}))?)
+    \s*\)
+    """.format(
+        **COLOR_PARTS
+    )
+)
 
 SUPPORTED_SPACES = list(Base.CS_MAP.values())
 

color_helper.sublime-settings

@@ -122,9 +122,15 @@
         // "ColorHelper.lib.coloraide.spaces.acescc.ACEScc",
         // "ColorHelper.lib.coloraide.spaces.acescg.ACEScg",
         // "ColorHelper.lib.coloraide.spaces.acescct.ACEScct",
+        // "ColorHelper.lib.coloraide.spaces.cam16.CAM16",
+        // "ColorHelper.lib.coloraide.spaces.cam16_jmh.CAM16JMh",
+        // "ColorHelper.lib.coloraide.spaces.cam16_ucs.CAM16UCS",
+        // "ColorHelper.lib.coloraide.spaces.cam16_ucs.CAM16SCD",
+        // "ColorHelper.lib.coloraide.spaces.cam16_ucs.CAM16LCD",
         // "ColorHelper.lib.coloraide.spaces.cmy.CMY",
         // "ColorHelper.lib.coloraide.spaces.cmyk.CMYK",
         // "ColorHelper.lib.coloraide.spaces.din99o.DIN99o",
+        // "ColorHelper.lib.coloraide.spaces.hct.HCT",
         // "ColorHelper.lib.coloraide.spaces.hpluv.HPLuv",
         // "ColorHelper.lib.coloraide.spaces.hsi.HSI",
         // "ColorHelper.lib.coloraide.spaces.hunter_lab.HunterLab",
@@ -136,10 +142,9 @@
         // "ColorHelper.lib.coloraide.spaces.lch99o.LCh99o",
         // "ColorHelper.lib.coloraide.spaces.orgb.oRGB",
         // "ColorHelper.lib.coloraide.spaces.prismatic.Prismatic",
-        // "ColorHelper.lib.coloraide.spaces.rec2100pq.Rec2100PQ",
+        // "ColorHelper.lib.coloraide.spaces.rec2100_hlg.Rec2100HLG",
+        // "ColorHelper.lib.coloraide.spaces.rec2100_pq.Rec2100PQ",
         // "ColorHelper.lib.coloraide.spaces.rlab.RLAB",
-        // "ColorHelper.lib.coloraide.spaces.ucs.UCS",
-        // "ColorHelper.lib.coloraide.spaces.uvw.UVW",
         // "ColorHelper.lib.coloraide.spaces.xyy.xyY",
         "ColorHelper.lib.coloraide.spaces.hsluv.HSLuv",
         "ColorHelper.lib.coloraide.spaces.lchuv.LChuv",

custom/ahex.py

@@ -52,7 +52,7 @@ def to_string(
         """Convert to Hex format."""
 
         options = kwargs
-        a = alg.no_nan(parent[-1])
+        a = parent.alpha(nans=False)
         show_alpha = alpha is not False and (alpha is True or a < 1.0)
 
         template = "#{:02x}{:02x}{:02x}{:02x}" if show_alpha else "#{:02x}{:02x}{:02x}"
@@ -61,7 +61,7 @@ def to_string(
 
         # Always fit hex
         method = None if not isinstance(fit, str) else fit
-        coords = alg.no_nans(parent.clone().fit(method=method)[:-1])
+        coords = parent.clone().fit(method=method).coords(nans=False)
         if show_alpha:
             value = template.format(
                 int(alg.round_half_up(a * 255.0)),

custom/ass_abgr.py

@@ -46,7 +46,7 @@ def to_string(cls, parent, *, options=None, alpha=None, precision=None, fit=True
         """Convert color to `&HAABBGGRR`."""
 
         options = kwargs
-        a = alg.no_nan(parent[-1])
+        a = parent.alpha(nans=False)
         show_alpha = alpha is not False and (alpha is True or a < 1.0)
 
         template = "&H{:02x}{:02x}{:02x}{:02x}" if show_alpha else "&H{:02x}{:02x}{:02x}"
@@ -55,7 +55,7 @@ def to_string(cls, parent, *, options=None, alpha=None, precision=None, fit=True
 
         # Always fit hex
         method = None if not isinstance(fit, str) else fit
-        coords = alg.no_nans(parent.clone().fit(method=method)[:-1])
+        coords = parent.clone().fit(method=method).coords(nans=False)
         if show_alpha:
             value = template.format(
                 int(alg.round_half_up(a * 255.0)),

custom/st_colormod.py

@@ -9,7 +9,9 @@
 from itertools import zip_longest as zipl
 import functools
 import math
-from ColorHelper.ch_util import get_base_color
+from ColorHelper.ch_util import get_base_color, COLOR_PARTS
+
+RE_CHAN_VALUE = re.compile(r'(?i)(?:[+\-]?(?:[0-9]*\.)?[0-9]+(?:e[-+]?[0-9]+)?(?:%|deg|rad|turn|grad)?|none)')
 
 BASE = get_base_color()
 
@@ -27,10 +29,10 @@
             \#(?:{hex}{{6}}(?:{hex}{{2}})?|{hex}{{3}}(?:{hex})?) |
             [\w][\w\d]*
         )
-        """.format(**parse.COLOR_PARTS)
+        """.format(**COLOR_PARTS)
     ),
     "functions": re.compile(r'(?i)[\w][\w\d]*\('),
-    "separators": re.compile(r'(?:{comma}|{space}|{slash})'.format(**parse.COLOR_PARTS))
+    "separators": re.compile(r'(?:{comma}|{space}|{slash})'.format(**COLOR_PARTS))
 }
 
 RE_ADJUSTERS = {
@@ -41,38 +43,38 @@
         (?:(\+\s+|\-\s+)?({strict_percent}|{strict_float})|(\*)?\s*({strict_percent}|{strict_float}))
         \s*\)
         """.format(
-            **parse.COLOR_PARTS
+            **COLOR_PARTS
         )
     ),
     "saturation": re.compile(
-        r'(?i)\s+s(?:aturation)?\((\+\s|\-\s|\*)?\s*({strict_percent})\s*\)'.format(**parse.COLOR_PARTS)
+        r'(?i)\s+s(?:aturation)?\((\+\s|\-\s|\*)?\s*({strict_percent})\s*\)'.format(**COLOR_PARTS)
     ),
     "lightness": re.compile(
-        r'(?i)\s+l(?:ightness)?\((\+\s|\-\s|\*)?\s*({strict_percent})\s*\)'.format(**parse.COLOR_PARTS)
+        r'(?i)\s+l(?:ightness)?\((\+\s|\-\s|\*)?\s*({strict_percent})\s*\)'.format(**COLOR_PARTS)
     ),
     "min-contrast_start": re.compile(r'(?i)\s+min-contrast\(\s*'),
     "blend_start": re.compile(r'(?i)\s+blenda?\(\s*'),
     "end": re.compile(r'(?i)\s*\)')
 }
 
-RE_HUE = re.compile(r'(?i){angle}'.format(**parse.COLOR_PARTS))
+RE_HUE = re.compile(r'(?i){angle}'.format(**COLOR_PARTS))
 RE_COLOR_START = re.compile(r'(?i)color\(\s*')
-RE_BLEND_END = re.compile(r'(?i)\s+({strict_percent})(?:\s+(rgb|hsl|hwb))?\s*\)'.format(**parse.COLOR_PARTS))
+RE_BLEND_END = re.compile(r'(?i)\s+({strict_percent})(?:\s+(rgb|hsl|hwb))?\s*\)'.format(**COLOR_PARTS))
 RE_BRACKETS = re.compile(r'(?:(\()|(\))|[^()]+)')
-RE_MIN_CONTRAST_END = re.compile(r'(?i)\s+({strict_float})\s*\)'.format(**parse.COLOR_PARTS))
+RE_MIN_CONTRAST_END = re.compile(r'(?i)\s+({strict_float})\s*\)'.format(**COLOR_PARTS))
 RE_VARS = re.compile(r'(?i)(?:(?<=^)|(?<=[\s\t\(,/]))(var\(\s*([-\w][-\w\d]*)\s*\))(?!\()(?=[\s\t\),/]|$)')
 
 HWB_MATCH = re.compile(
     r"""(?xi)
     \b(hwb)\(\s*
     (?:
         # Space separated format
-        {angle}{space}{percent}{space}{percent}(?:{slash}(?:{percent}|{float}))? |
+        {angle}{loose_space}{percent}{loose_space}{percent}(?:{slash}(?:{percent}|{float}))? |
         # comma separated format
         {angle}{comma}{percent}{comma}{percent}(?:{comma}(?:{percent}|{float}))?
     )
     \s*\)
-    """.format(**parse.COLOR_PARTS)
+    """.format(**COLOR_PARTS)
 )
 
 
@@ -188,7 +190,10 @@ def match(cls, string, start=0, fullmatch=True):
 
         m = HWB_MATCH.match(string, start)
         if m is not None and (not fullmatch or m.end(0) == len(string)):
-            return parse.parse_channels(string[m.end(1) + 1:m.end(0) - 1], cls.BOUNDS), m.end(0)
+            return parse.parse_channels(
+                list(RE_CHAN_VALUE.findall(string[m.end(1) + 1:m.end(0) - 1])),
+                cls.CHANNELS, scaled=True
+            ), m.end(0)
         return None
 
     @classmethod
@@ -198,8 +203,10 @@ def to_string(
         *,
         alpha=None,
         precision=None,
+        percent: bool = True,
         fit=True,
         none=False,
+        comma: bool = False,
         **kwargs
     ) -> str:
         """Convert to CSS."""
@@ -212,7 +219,9 @@ def to_string(
             fit=fit,
             none=none,
             color=kwargs.get('color', False),
-            legacy=kwargs.get('comma', False)
+            percent=True if comma else percent,
+            scale=100,
+            legacy=comma
         )
 
 
@@ -349,7 +358,7 @@ def adjust_base(self, base, string):
 
         self._color = base
         pattern = "color({} {})".format(self._color.clone().clip().to_string(precision=-1), string)
-        color, start = self._adjust(pattern)
+        color, _ = self._adjust(pattern)
         if color is not None:
             self._color.update(color)
         else:
@@ -486,12 +495,12 @@ def min_contrast(self, color1, color2, target):
         if is_dark:
             primary = "whiteness"
             secondary = "blackness"
-            min_mix = orig.whiteness * 100
+            min_mix = orig[primary] * 100
             max_mix = 100
         else:
             primary = "blackness"
             secondary = "whiteness"
-            min_mix = orig.blackness * 100
+            min_mix = orig[primary] * 100
             max_mix = 100
         orig_ratio = ratio
         last_ratio = 0
@@ -620,13 +629,15 @@ def _parse(
                 s = color
                 space_class = cls.CS_MAP.get(s)
                 if not space_class:
-                    raise ValueError("'{}' is not a registered color space")
+                    raise ValueError("'{}' is not a registered color space".format(s))
                 num_channels = len(space_class.CHANNELS)
-                if len(data) < num_channels:
-                    data = list(data) + [alg.NaN] * (num_channels - len(data))
+                num_data = len(data)
+                if num_data < num_channels:
+                    data = list(data) + [alg.NaN] * (num_channels - num_data)
                 coords = [alg.clamp(float(v), *c.limit) for c, v in zipl(space_class.CHANNELS, data)]
                 coords.append(alg.clamp(float(alpha), *space_class.channels[-1].limit))
                 obj = space_class, coords
+
             # Parse a CSS string
             else:
                 m = cls._match(color, fullmatch=True, variables=variables)
@@ -635,18 +646,18 @@ def _parse(
                 coords = [alg.clamp(float(v), *c.limit) for c, v in zipl(m[0].CHANNELS, m[1])]
                 coords.append(alg.clamp(float(m[2]), *m[0].channels[-1].limit))
                 obj = m[0], coords
+
+        # Handle a color instance
         elif isinstance(color, BASE):
-            # Handle a color instance
             space_class = cls.CS_MAP.get(color.space())
             if not space_class:
-                raise ValueError("'{}' is not a registered color space")
+                raise ValueError("'{}' is not a registered color space".format(color.space()))
             obj = space_class, color[:]
+
+        # Handle a color dictionary
         elif isinstance(color, Mapping):
-            # Handle a color dictionary
-            space = color['space']
-            coords = color['coords']
-            alpha = color.get('alpha', 1.0)
-            obj = cls._parse(space, coords, alpha)
+            obj = cls._parse(color['space'], color['coords'], color.get('alpha', 1.0))
+
         else:
             raise TypeError("'{}' is an unrecognized type".format(type(color)))
 
@@ -710,15 +721,15 @@ def new(self, color, data=None, alpha=util.DEF_ALPHA, *, variables=None, **kwarg
 
         return type(self)(color, data, alpha, variables=variables, **kwargs)
 
-    def update(self, color, data=None, alpha=util.DEF_ALPHA, *, variables=None, **kwargs):
+    def update(self, color, data=None, alpha=util.DEF_ALPHA, *, norm=True, variables=None, **kwargs):
         """Update the existing color space with the provided color."""
 
         space = self.space()
         self._space, self._coords = self._parse(
             color, data=data, alpha=alpha, variables=variables, **kwargs
         )
         if self._space.NAME != space:
-            self.convert(space, in_place=True)
+            self.convert(space, in_place=True, norm=norm)
         return self
 
     def mutate(self, color, data=None, alpha=util.DEF_ALPHA, *, variables=None, **kwargs):

custom/tmtheme.py

@@ -4,7 +4,9 @@
 import re
 from ColorHelper.ch_util import get_base_color
 
-RE_COMPRESS = re.compile(r'(?i)^#({hex})\1({hex})\2({hex})\3(?:({hex})\4)?$'.format(**parse.COLOR_PARTS))
+HEX = r'[a-f0-9]'
+
+RE_COMPRESS = re.compile(r'(?i)^#({hex})\1({hex})\2({hex})\3(?:({hex})\4)?$'.format(hex=HEX))
 
 MATCH = re.compile(
     r"""(?xi)
@@ -14,7 +16,7 @@
         # Names
         \b(?<!\#)[a-z][a-z0-9]{{2,}}(?!\()\b
     )
-    """.format(**parse.COLOR_PARTS)
+    """.format(hex=HEX)
 )
 
 name2hex_map = {

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, 7, 1, "final")
+__version_info__ = Version(2, 0, 1, "final")
 __version__ = __version_info__._get_canonical()

lib/coloraide/algebra.py

@@ -164,6 +164,22 @@ def nlog(value: float) -> float:
     return math.copysign(1, value) * math.log(abs(value))
 
 
+def rect_to_polar(a: float, b: float) -> Tuple[float, float]:
+    """Take rectangular coordinates and make them polar."""
+
+    c = math.sqrt(a ** 2 + b ** 2)
+    h = math.degrees(math.atan2(b, a)) % 360
+    return c, h
+
+
+def polar_to_rect(c: float, h: float) -> Tuple[float, float]:
+    """Take rectangular coordinates and make them polar."""
+
+    a = c * math.cos(math.radians(h))
+    b = c * math.sin(math.radians(h))
+    return a, b
+
+
 ################################
 # Interpolation and splines
 ################################
@@ -481,7 +497,7 @@ def _cross_pad(a: ArrayLike, s: Tuple[int, ...]) -> Array:
     m = acopy(a)
 
     # Initialize indexes so we can properly write our data
-    total = prod(cast(Iterator[int], s[:-1]))
+    total = prod(s[:-1])
     idx = [0] * (len(s) - 1)
 
     for c in range(total):