Tweak color parsing and tests

Author: bcbnz

pgfutils.py

@@ -194,7 +194,7 @@ class ColorError(ValueError):
     pass
 
 
-def parse_color(spec: Literal["none", "transparent"] | str | float | tuple[float]):
+def parse_color(spec: Literal["none", "transparent"] | str | float | tuple[float, ...]):
     """Parse a color specification to a Matplotlib color.
 
     Recognised color formats are:
@@ -219,45 +219,49 @@ def parse_color(spec: Literal["none", "transparent"] | str | float | tuple[float
         The value could not be interpreted as a color.
 
     """
+    if isinstance(spec, list):
+        spec = tuple(spec)
+
     # Transparent.
     if spec in {"none", "transparent", ""}:
         return "none"
 
     # Single floating point number: grayscale.
     try:
         gray = float(spec)
-    except ValueError:
+    except (TypeError, ValueError):
         pass
     else:
         if not (0 <= gray <= 1):
-            raise ColorError("greyscale floats must be in [0, 1].")
+            raise ColorError("greyscale floats must be in [0, 1]")
 
         # For historical reasons Matlotlib requires this to be a string.
-        return spec
+        return str(gray)
 
     # Nth color in the cycle (i.e., C1, C2 etc), or a named color. Unfortunately,
     # this returns True for grayscale values outside [0, 1] so we have to do our own
     # check above.
     if matplotlib.colors.is_color_like(spec):
         return spec
 
-    # Anything else we accept is valid Python syntax, so parse it.
-    try:
-        parsed = ast.literal_eval(spec)
-    except (SyntaxError, TypeError, ValueError):
-        raise ColorError(f"could not interpret '{spec}' as a color.")
+    # Any other string we accept is valid Python syntax, so parse it.
+    if isinstance(spec, str):
+        try:
+            spec = ast.literal_eval(spec)
+        except (SyntaxError, TypeError, ValueError):
+            raise ColorError(f"could not interpret '{spec}' as a color.")
 
     # Needs to be a list or tuple of channel values.
-    if not isinstance(parsed, (list, tuple)):
+    if not isinstance(spec, (list, tuple)):
         raise ColorError(f"could not interpret '{spec}' as a color.")
 
     # Filter out Booleans which Matplotlib would treat as 0 or 1.
-    if any(isinstance(entry, bool) for entry in parsed):
+    if any(isinstance(entry, bool) for entry in spec):
         raise ColorError(f"could not interpret '{spec}' as a color.")
 
     # And get Matplotlib to convert to a color.
     try:
-        return matplotlib.colors.to_rgba(parsed)
+        return matplotlib.colors.to_rgba(spec)
     except ValueError as e:
         raise ColorError(str(e))
 

tests/test_colors.py

@@ -2,25 +2,24 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 from matplotlib.colors import get_named_colors_mapping
+import numpy as np
 import pytest
 
-from pgfutils import ColorError, _config, _config_reset
+from pgfutils import ColorError, parse_color
 
 
-class TestColorClass:
+class TestColor:
     def test_greyscale(self):
         """Grayscale fraction parsing..."""
-        _config_reset()
-
         # Test a range of valid floats.
         # N.B., Matplotlib uses strings for greyscale.
-        for f in (0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0):
-            _config.read_kwargs(figure_background=f)
-            assert _config["pgfutils"].getcolor("figure_background") == str(f)
+        for f in (0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0):
+            assert parse_color(f) == str(f)
+            assert parse_color(str(f)) == str(f)
 
         # The same things as strings.
         for s in (
-            "0",
+            "0.0",
             "0.1",
             "0.2",
             "0.3",
@@ -32,56 +31,39 @@ def test_greyscale(self):
             "0.9",
             "1.0",
         ):
-            _config.read_kwargs(figure_background=s)
-            assert _config["pgfutils"].getcolor("figure_background") == s
+            assert parse_color(s) == s
 
         # Check numbers outside the valid range.
         for f in (1.01, -1):
-            with pytest.raises(ColorError):
-                _config.read_kwargs(axes_background=f)
-                _config["pgfutils"].getcolor("axes_background")
+            with pytest.raises(ColorError, match=r"must be in \[0, 1\]"):
+                parse_color(f)
 
     def test_named(self):
         """Named color parsing..."""
-        _config_reset()
-
         # Try all known Matplotlib colors.
         for color in get_named_colors_mapping().keys():
-            _config.read_kwargs(axes_background=color)
-            assert _config["pgfutils"].getcolor("axes_background") == color
+            assert parse_color(color) == color
 
         # And check it rejects non-existent named colors.
-        with pytest.raises(ColorError):
-            _config.read_kwargs(axes_background="nonexistentuglycolor")
-            _config["pgfutils"].getcolor("axes_background")
+        with pytest.raises(ColorError, match="could not interpret .+ as a color"):
+            parse_color("some_ugly_color")
 
     def test_cycle(self):
         """Color cycle parsing..."""
-        _config_reset()
-
         for i in range(0, 10):
             cycle = "C{0:d}".format(i)
-            _config.read_kwargs(axes_background=cycle)
-            assert _config["pgfutils"].getcolor("axes_background") == cycle
+            assert parse_color(cycle) == cycle
 
     def test_transparent(self):
         """Color parsing supports transparency..."""
-        _config_reset()
-        _config.read_kwargs(axes_background="none")
-        assert _config["pgfutils"].getcolor("axes_background") == "none"
-        _config.read_kwargs(axes_background="transparent")
-        assert _config["pgfutils"].getcolor("axes_background") == "none"
-        _config.read_kwargs(axes_background="")
-        assert _config["pgfutils"].getcolor("axes_background") == "none"
+        assert parse_color("none") == "none"
+        assert parse_color("transparent") == "none"
+        assert parse_color("") == "none"
 
     def test_rgb(self):
         """RGB list/tuple color parsing..."""
-        _config_reset()
-
         # Generate a set of valid colors. We have to include an alpha channel
         # here as it is always returned from the parser with alpha=1.
-        import numpy as np
-
         c = np.linspace(0, 1, 5)
         a = (c * 0) + 1.0
         colors = np.stack(np.meshgrid(c, c, c, a), -1).reshape(-1, 4)
@@ -90,71 +72,55 @@ def test_rgb(self):
         for color in colors:
             list_c = color.tolist()
             tuple_c = tuple(list_c)
-            _config.read_kwargs(figure_background=str(list_c[:-1]))
-            assert _config["pgfutils"].getcolor("figure_background") == tuple_c
-            _config.read_kwargs(axes_background=str(tuple_c[:-1]))
-            assert _config["pgfutils"].getcolor("axes_background") == tuple_c
+            assert parse_color(list_c) == tuple_c
+            assert parse_color(tuple_c) == tuple_c
 
         # Check it fails on channels with invalid values.
         color = [0, 0, 0]
         for channel in range(3):
-            for value in (-0.1, 1.2, "a", True, False, None):
+            for value in (-0.1, 1.2, "a", None):
+                color[channel] = value
                 with pytest.raises(ColorError):
-                    color[channel] = value
-                    _config.read_kwargs(axes_background=color)
-                    _config["pgfutils"].getcolor("axes_background")
+                    parse_color(color)
             color[channel] = 0
 
         # And some invalid formats too.
         for value in ("fail", "yes", "no"):
-            with pytest.raises(ColorError):
-                _config.read_kwargs(axes_background=value)
-                _config["pgfutils"].getcolor("axes_background")
+            with pytest.raises(ColorError, match="could not interpret.+as a color"):
+                parse_color(value)
 
     def test_rgba(self):
         """RGBA list/tuple color parsing..."""
-        _config_reset()
-
         # Generate a set of valid colors.
-        import numpy as np
-
         c = np.linspace(0, 1, 5)
         colors = np.stack(np.meshgrid(c, c, c, c), -1).reshape(-1, 4)
 
         # Check they are accepted. The parser always returns colors as tuples.
         for color in colors:
             list_c = color.tolist()
             tuple_c = tuple(list_c)
-            _config.read_kwargs(figure_background=str(list_c))
-            assert _config["pgfutils"].getcolor("figure_background") == tuple_c
-            _config.read_kwargs(axes_background=str(tuple_c))
-            assert _config["pgfutils"].getcolor("axes_background") == tuple_c
+            assert parse_color(list_c) == tuple_c
+            assert parse_color(tuple_c) == tuple_c
 
         # Check it fails on channels with invalid values.
         color = [0, 0, 0, 0]
         for channel in range(4):
-            for value in (-0.1, 1.2, "a", True, False, None):
+            for value in (-0.1, 1.2, "a", None):
+                color[channel] = value
                 with pytest.raises(ColorError):
-                    color[channel] = value
-                    _config.read_kwargs(axes_background=color)
-                    _config["pgfutils"].getcolor("axes_background")
+                    parse_color(color)
             color[channel] = 0
 
         # And some invalid formats too.
         for value in ("fail", "yes", "no"):
-            with pytest.raises(ColorError):
-                _config.read_kwargs(axes_background=value)
-                _config["pgfutils"].getcolor("axes_background")
+            with pytest.raises(ColorError, match="could not interpret.+as a color"):
+                parse_color(value)
 
     def test_invalid_tuples(self):
         """Check RGB/RGBA parsing rejects tuples of invalid length..."""
-        _config_reset()
         with pytest.raises(ColorError):
-            _config.read_kwargs(axes_background="(1,)")
-            _config["pgfutils"].getcolor("axes_background")
+            parse_color((1,))
         with pytest.raises(ColorError):
-            _config.read_kwargs(axes_background="(1,1)")
-            _config["pgfutils"].getcolor("axes_background")
+            parse_color((1, 1))
         with pytest.raises(ColorError):
-            _config.read_kwargs(axes_background="(1,1,1,1,1)")
-            _config["pgfutils"].getcolor("axes_background")
+            parse_color((1, 1, 1, 1, 1))