Revert "simplify"

This reverts commit ab39326.

Author: rcomer

lib/matplotlib/_style_helpers.py

@@ -1,44 +1,41 @@
 import collections.abc
 import itertools
 
+import numpy as np
+
 import matplotlib.cbook as cbook
 import matplotlib.colors as mcolors
 import matplotlib.lines as mlines
 
 
-
 def check_non_empty(key, value):
     """Raise a TypeError if an empty sequence is passed"""
-    if isinstance(value, collections.abc.Sized) and len(value) == 0:
+    if (not cbook.is_scalar_or_string(value) and
+            isinstance(value, collections.abc.Sized) and len(value) == 0):
         raise TypeError(f'{key} must not be an empty sequence')
 
 
-def iterate_styles(kw):
+def style_generator(kw):
     """
     Helper for handling style sequences (e.g. facecolor=['r', 'b', 'k']) within plotting
-    methods that repeatedly call other plotting methods (e.g. hist, stackplot).
-
-    Given a dictionary of keyword parameters, yield a series of copies of the
-    dictionary.  Style parameters expressed as sequences are replaced in the copy with
-    the next element of the sequence.
-
-    Note 'color' is deliberately not handled since the calling methods have their own
-    handling for that.
+    methods that repeatedly call other plotting methods (e.g. hist, stackplot).  Remove
+    style keywords from the given dictionary.  Return the reduced dictionary together
+    with a generator which provides a series of dictionaries to be used in each call to
+    the wrapped function.
     """
     kw_iterators = {}
     remaining_kw = {}
     for key, value in kw.items():
-        if cbook.is_scalar_or_string(value):
-            # No iteration required
-            remaining_kw[key] = value
-
-        elif key in ['facecolor', 'edgecolor']:
-            check_non_empty(key, value)
-            kw_iterators[key] = itertools.cycle(mcolors.to_rgba_array(value))
+        if key in ['facecolor', 'edgecolor']:
+            if value is None or cbook._str_lower_equal(value, 'none'):
+                kw_iterators[key] = itertools.repeat(value)
+            else:
+                check_non_empty(key, value)
+                kw_iterators[key] = itertools.cycle(mcolors.to_rgba_array(value))
 
         elif key in ['hatch', 'linewidth']:
             check_non_empty(key, value)
-            kw_iterators[key] = itertools.cycle(value)
+            kw_iterators[key] = itertools.cycle(np.atleast_1d(value))
 
         elif key == 'linestyle':
             check_non_empty(key, value)
@@ -47,6 +44,8 @@ def iterate_styles(kw):
         else:
             remaining_kw[key] = value
 
+    def style_gen():
+        while True:
+            yield {key: next(val) for key, val in kw_iterators.items()}
 
-    while True:
-        yield {key: next(val) for key, val in kw_iterators.items()} | remaining_kw
+    return remaining_kw, style_gen()

lib/matplotlib/axes/_axes.py

@@ -3324,7 +3324,7 @@ def grouped_bar(self, heights, *, positions=None, group_spacing=1.5, bar_spacing
             # TODO: do we want to be more restrictive and check lengths?
             colors = itertools.cycle(colors)
 
-        kwargs_gen = _style_helpers.iterate_styles(kwargs)
+        kwargs, style_gen = _style_helpers.style_generator(kwargs)
 
         bar_width = (group_distance /
                      (num_datasets + (num_datasets - 1) * bar_spacing + group_spacing))
@@ -3339,15 +3339,16 @@ def grouped_bar(self, heights, *, positions=None, group_spacing=1.5, bar_spacing
         # place the bars, but only use numerical positions, categorical tick labels
         # are handled separately below
         bar_containers = []
-        for i, (hs, label, color) in enumerate(zip(heights, labels, colors)):
+        for i, (hs, label, color, styles) in enumerate(zip(heights, labels, colors,
+                                                           style_gen)):
             lefts = (group_centers - 0.5 * group_distance + margin_abs
                      + i * (bar_width + bar_spacing_abs))
             if orientation == "vertical":
                 bc = self.bar(lefts, hs, width=bar_width, align="edge",
-                              label=label, color=color, **next(kwargs_gen))
+                              label=label, color=color, **styles, **kwargs)
             else:
                 bc = self.barh(lefts, hs, height=bar_width, align="edge",
-                               label=label, color=color, **next(kwargs_gen))
+                               label=label, color=color, **styles, **kwargs)
             bar_containers.append(bc)
 
         if tick_labels is not None:
@@ -7640,18 +7641,18 @@ def hist(self, x, bins=None, range=None, density=False, weights=None,
         if histtype == "step":
             kwargs.setdefault('edgecolor', colors)
 
-        kwargs_gen = _style_helpers.iterate_styles(kwargs)
+        kwargs, style_gen = _style_helpers.style_generator(kwargs)
 
         for patch, lbl in itertools.zip_longest(patches, labels):
             if not patch:
                 continue
-            kw = next(kwargs_gen)
             p = patch[0]
-            p._internal_update(kw)
+            kwargs.update(next(style_gen))
+            p._internal_update(kwargs)
             if lbl is not None:
                 p.set_label(lbl)
             for p in patch[1:]:
-                p._internal_update(kw)
+                p._internal_update(kwargs)
                 p.set_label('_nolegend_')
 
         if nx == 1:

lib/matplotlib/stackplot.py

@@ -96,7 +96,7 @@ def stackplot(axes, x, *args,
     kwargs = cbook.normalize_kwargs(kwargs, collections.PolyCollection)
     kwargs.setdefault('facecolor', colors)
 
-    kwargs_gen = _style_helpers.iterate_styles(kwargs)
+    kwargs, style_gen = _style_helpers.style_generator(kwargs)
 
     # Assume data passed has not been 'stacked', so stack it here.
     # We'll need a float buffer for the upcoming calculations.
@@ -136,13 +136,13 @@ def stackplot(axes, x, *args,
     # Color between x = 0 and the first array.
     coll = axes.fill_between(x, first_line, stack[0, :],
                              label=next(labels, None),
-                             **next(kwargs_gen))
+                             **next(style_gen), **kwargs)
     coll.sticky_edges.y[:] = [0]
     r = [coll]
 
     # Color between array i-1 and array i
     for i in range(len(y) - 1):
         r.append(axes.fill_between(x, stack[i, :], stack[i + 1, :],
                                    label=next(labels, None),
-                                   **next(kwargs_gen)))
+                                   **next(style_gen), **kwargs))
     return r

lib/matplotlib/tests/test__style_helpers.py

@@ -2,75 +2,76 @@
 
 import matplotlib.colors as mcolors
 from matplotlib.lines import _get_dash_pattern
-from matplotlib._style_helpers import iterate_styles
+from matplotlib._style_helpers import style_generator
 
 
 @pytest.mark.parametrize('key, value', [('facecolor', ["b", "g", "r"]),
                                         ('edgecolor', ["b", "g", "r"]),
                                         ('hatch', ["/", "\\", "."]),
                                         ('linestyle', ["-", "--", ":"]),
                                         ('linewidth', [1, 1.5, 2])])
-def test_iterate_styles_list(key, value):
+def test_style_generator_list(key, value):
     kw = {'foo': 12, key: value}
-    gen_kw = iterate_styles(kw)
+    new_kw, gen = style_generator(kw)
+
+    assert new_kw == {'foo': 12}
 
     for v in value * 2:  # Result should repeat
-        kw_dict = next(gen_kw)
-        assert len(kw_dict) == 2
-        assert kw_dict['foo'] == 12
+        style_dict = next(gen)
+        assert len(style_dict) == 1
         if key.endswith('color'):
-            assert mcolors.same_color(v, kw_dict[key])
+            assert mcolors.same_color(v, style_dict[key])
         elif key == 'linestyle':
-            assert _get_dash_pattern(v) == kw_dict[key]
+            assert _get_dash_pattern(v) == style_dict[key]
         else:
-            assert v == kw_dict[key]
+            assert v == style_dict[key]
 
 
 @pytest.mark.parametrize('key, value', [('facecolor', "b"),
                                         ('edgecolor', "b"),
                                         ('hatch', "/"),
                                         ('linestyle', "-"),
                                         ('linewidth', 1)])
-def test_iterate_styles_single(key, value):
+def test_style_generator_single(key, value):
     kw = {'foo': 12, key: value}
-    gen_kw = iterate_styles(kw)
+    new_kw, gen = style_generator(kw)
 
+    assert new_kw == {'foo': 12}
     for _ in range(2):  # Result should repeat
-        kw_dict = next(gen_kw)
-        assert len(kw_dict) == 2
-        assert kw_dict['foo'] == 12
+        style_dict = next(gen)
         if key.endswith('color'):
-            assert mcolors.same_color(value, kw_dict[key])
+            assert mcolors.same_color(value, style_dict[key])
+        elif key == 'linestyle':
+            assert _get_dash_pattern(value) == style_dict[key]
         else:
-            assert value == kw_dict[key]
+            assert value == style_dict[key]
 
 
 @pytest.mark.parametrize('key', ['facecolor', 'hatch', 'linestyle'])
-def test_iterate_styles_empty(key):
+def test_style_generator_empty(key):
     kw = {key: []}
-    gen_kw = iterate_styles(kw)
     with pytest.raises(TypeError, match=f'{key} must not be an empty sequence'):
-        next(gen_kw)
+        style_generator(kw)
 
 
-def test_iterate_styles_sequence_type_styles():
+def test_style_generator_sequence_type_styles():
     kw = {'facecolor':  ('r', 0.5),
           'edgecolor': [0.5, 0.5, 0.5],
           'linestyle': (0, (1, 1))}
 
-    gen_kw = iterate_styles(kw)
+    _, gen = style_generator(kw)
     for _ in range(2):  # Result should repeat
-        kw_dict = next(gen_kw)
-        mcolors.same_color(kw['facecolor'], kw_dict['facecolor'])
-        mcolors.same_color(kw['edgecolor'], kw_dict['edgecolor'])
-        kw['linestyle'] == kw_dict['linestyle']
+        style_dict = next(gen)
+        mcolors.same_color(kw['facecolor'], style_dict['facecolor'])
+        mcolors.same_color(kw['edgecolor'], style_dict['edgecolor'])
+        kw['linestyle'] == style_dict['linestyle']
 
 
-def test_iterate_styles_none():
+def test_style_generator_none():
     kw = {'facecolor': 'none',
           'edgecolor': 'none'}
-    gen_kw = iterate_styles(kw)
+    _, gen = style_generator(kw)
     for _ in range(2):  # Result should repeat
-        kw_dict = next(gen_kw)
-        assert kw_dict['facecolor'] == 'none'
-        assert kw_dict['edgecolor'] == 'none'
+        style_dict = next(gen)
+        assert style_dict['facecolor'] == 'none'
+        assert style_dict['edgecolor'] == 'none'