CLN: clean color selection in _matplotlib/style

pandas/plotting/_matplotlib/style.py

@@ -1,4 +1,14 @@
-# being a bit too dynamic
+from typing import (
+    TYPE_CHECKING,
+    Collection,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
 import warnings
 
 import matplotlib.cm as cm
@@ -9,74 +19,174 @@
 
 import pandas.core.common as com
 
+if TYPE_CHECKING:
+    from matplotlib.colors import Colormap
+
+
+Color = Union[str, Sequence[float]]
+
 
 def get_standard_colors(
-    num_colors: int, colormap=None, color_type: str = "default", color=None
+    num_colors: int,
+    colormap: Optional["Colormap"] = None,
+    color_type: str = "default",
+    color: Optional[Union[Dict[str, Color], Color, Collection[Color]]] = None,
 ):
-    import matplotlib.pyplot as plt
-
+    if isinstance(color, dict):
+        return color
+
+    colors = _get_colors(
+        color=color,
+        colormap=colormap,
+        color_type=color_type,
+        num_colors=num_colors,
+    )
+
+    return _cycle_colors(colors, num_colors=num_colors)
+
+
+def _get_colors(
+    *,
+    color: Optional[Union[Color, Collection[Color]]],
+    colormap: Optional[Union[str, "Colormap"]],
+    color_type: str,
+    num_colors: int,
+) -> List[Color]:
+    """Get colors from user input."""
     if color is None and colormap is not None:
-        if isinstance(colormap, str):
-            cmap = colormap
-            colormap = cm.get_cmap(colormap)
-            if colormap is None:
-                raise ValueError(f"Colormap {cmap} is not recognized")
-        colors = [colormap(num) for num in np.linspace(0, 1, num=num_colors)]
+        return _get_colors_from_colormap(colormap, num_colors=num_colors)
     elif color is not None:
         if colormap is not None:
             warnings.warn(
                 "'color' and 'colormap' cannot be used simultaneously. Using 'color'"
             )
-        colors = (
-            list(color)
-            if is_list_like(color) and not isinstance(color, dict)
-            else color
-        )
+        return _get_colors_from_color(color)
     else:
-        if color_type == "default":
-            # need to call list() on the result to copy so we don't
-            # modify the global rcParams below
-            try:
-                colors = [c["color"] for c in list(plt.rcParams["axes.prop_cycle"])]
-            except KeyError:
-                colors = list(plt.rcParams.get("axes.color_cycle", list("bgrcmyk")))
-            if isinstance(colors, str):
-                colors = list(colors)
-
-            colors = colors[0:num_colors]
-        elif color_type == "random":
-
-            def random_color(column):
-                """ Returns a random color represented as a list of length 3"""
-                # GH17525 use common._random_state to avoid resetting the seed
-                rs = com.random_state(column)
-                return rs.rand(3).tolist()
-
-            colors = [random_color(num) for num in range(num_colors)]
-        else:
-            raise ValueError("color_type must be either 'default' or 'random'")
+        return _get_colors_from_color_type(color_type, num_colors=num_colors)
 
-    if isinstance(colors, str) and _is_single_color(colors):
-        # GH #36972
-        colors = [colors]
 
-    # Append more colors by cycling if there is not enough color.
-    # Extra colors will be ignored by matplotlib if there are more colors
-    # than needed and nothing needs to be done here.
+def _cycle_colors(colors: List[Color], num_colors: int) -> List[Color]:
+    """Append more colors by cycling if there is not enough color.
+
+    Extra colors will be ignored by matplotlib if there are more colors
+    than needed and nothing needs to be done here.
+    """
     if len(colors) < num_colors:
-        try:
-            multiple = num_colors // len(colors) - 1
-        except ZeroDivisionError:
-            raise ValueError("Invalid color argument: ''")
+        multiple = num_colors // len(colors) - 1
         mod = num_colors % len(colors)
-
         colors += multiple * colors
         colors += colors[:mod]
 
     return colors
 
 
-def _is_single_color(color: str) -> bool:
+def _get_colors_from_colormap(
+    colormap: Union[str, "Colormap"],
+    num_colors: int,
+) -> List[Color]:
+    """Get colors from colormap."""
+    colormap = _get_cmap_instance(colormap)
+    return [colormap(num) for num in np.linspace(0, 1, num=num_colors)]
+
+
+def _get_cmap_instance(colormap: Union[str, "Colormap"]) -> "Colormap":
+    """Get instance of matplotlib colormap."""
+    if isinstance(colormap, str):
+        cmap = colormap
+        colormap = cm.get_cmap(colormap)
+        if colormap is None:
+            raise ValueError(f"Colormap {cmap} is not recognized")
+    return colormap
+
+
+def _get_colors_from_color(
+    color: Union[Color, Collection[Color]],
+) -> List[Color]:
+    """Get colors from user input color."""
+    if len(color) == 0:
+        raise ValueError(f"Invalid color argument: {color}")
+
+    if _is_single_color(color):
+        color = cast(Color, color)
+        return [color]
+
+    color = cast(Collection[Color], color)
+    return list(_gen_list_of_colors_from_iterable(color))
+
+
+def _is_single_color(color: Union[Color, Collection[Color]]) -> bool:
+    """Check if ``color`` is a single color, not a sequence of colors.
+
+    Single color is of these kinds:
+        - Named color "red"
+        - Alias "g"
+        - Sequence of floats, such as (0.1, 0.2, 0.3) or (0.1, 0.2, 0.3, 0.4).
+
+    See Also
+    --------
+    _is_single_string_color
+    """
+    if isinstance(color, str) and _is_single_string_color(color):
+        # GH #36972
+        return True
+
+    if _is_floats_color(color):
+        return True
+
+    return False
+
+
+def _gen_list_of_colors_from_iterable(color: Collection[Color]) -> Iterator[Color]:
+    """
+    Yield colors from string of several letters or from collection of colors.
+    """
+    for x in color:
+        if _is_single_color(x):
+            yield x
+        else:
+            raise ValueError(f"Invalid color {x}")
+
+
+def _is_floats_color(color: Union[Color, Collection[Color]]) -> bool:
+    """Check if color comprises a sequence of floats representing color."""
+    return bool(
+        is_list_like(color)
+        and (len(color) == 3 or len(color) == 4)
+        and all(isinstance(x, (int, float)) for x in color)
+    )
+
+
+def _get_colors_from_color_type(color_type: str, num_colors: int) -> List[Color]:
+    """Get colors from user input color type."""
+    if color_type == "default":
+        return _get_default_colors(num_colors)
+    elif color_type == "random":
+        return _get_random_colors(num_colors)
+    else:
+        raise ValueError("color_type must be either 'default' or 'random'")
+
+
+def _get_default_colors(num_colors: int) -> List[Color]:
+    """Get ``num_colors`` of default colors from matplotlib rc params."""
+    import matplotlib.pyplot as plt
+
+    colors = [c["color"] for c in plt.rcParams["axes.prop_cycle"]]
+    return colors[0:num_colors]
+
+
+def _get_random_colors(num_colors: int) -> List[Color]:
+    """Get ``num_colors`` of random colors."""
+    return [_random_color(num) for num in range(num_colors)]
+
+
+def _random_color(column: int) -> List[float]:
+    """Get a random color represented as a list of length 3"""
+    # GH17525 use common._random_state to avoid resetting the seed
+    rs = com.random_state(column)
+    return rs.rand(3).tolist()
+
+
+def _is_single_string_color(color: Color) -> bool:
     """Check if ``color`` is a single color.
 
     Examples of single colors:
@@ -85,11 +195,12 @@ def _is_single_color(color: str) -> bool:
         - 'red'
         - 'green'
         - 'C3'
+        - 'firebrick'
 
     Parameters
     ----------
-    color : string
-        Color string.
+    color : Color
+        Color string or sequence of floats.
 
     Returns
     -------