Make Artist.set() apply properties in the order in which they are given.

anntzer · anntzer · commit 17ccb3e12b22 · 2020-02-12T10:32:35.000+01:00
... with a deprecation period (see changelog).

- This is consistent with Artist.update, and we don't reorder separate
  calls to set_color and set_edgecolor either (we can't really to that,
  indeed).
- The _prop_order mechanism was a slightly complex machinery for a
  single use case (applying "color" first).
- Writing `p.set(edgecolor="r", color="g")` seems a bit twisted anyways.

Also rewrote (and simplified) normalize kwargs to make it *also*
maintain kwarg order, as that's necessary to make the warning emitted in
the correct cases.
diff --git a/doc/api/next_api_changes/deprecations.rst b/doc/api/next_api_changes/deprecations.rst
@@ -211,3 +211,12 @@ The *clear_temp* parameter and attribute of `.FileMovieWriter` is
 deprecated.  In the future, files placed in a temporary directory (using
 ``frame_prefix=None``, the default) will be cleared; files placed elsewhere
 will not.
+
+Reordering of parameters by `.Artist.set`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+In a future version, ``Artist.set`` will apply artist properties in the order
+in which they are given.  This only affects the interaction between the
+*color*, *edgecolor*, *facecolor*, and, for `.Collection`\s, *alpha*
+properties: the *color* property now needs to be passed first in order not to
+override the other properties.  This is consistent with e.g. `.Artist.update`,
+which did not reorder the properties passed to it.
diff --git a/lib/matplotlib/artist.py b/lib/matplotlib/artist.py
@@ -62,10 +62,6 @@ class Artist:
     """
 
     zorder = 0
-    # order of precedence when bulk setting/updating properties
-    # via update.  The keys should be property names and the values
-    # integers
-    _prop_order = dict(color=-1)
 
     def __init__(self):
         self._stale = True
@@ -1077,10 +1073,31 @@ def properties(self):
     def set(self, **kwargs):
         """A property batch setter.  Pass *kwargs* to set properties."""
         kwargs = cbook.normalize_kwargs(kwargs, self)
-        props = OrderedDict(
-            sorted(kwargs.items(), reverse=True,
-                   key=lambda x: (self._prop_order.get(x[0], 0), x[0])))
-        return self.update(props)
+        move_color_to_start = False
+        if "color" in kwargs:
+            keys = [*kwargs]
+            i_color = keys.index("color")
+            props = ["edgecolor", "facecolor"]
+            if any(tp.__module__ == "matplotlib.collections"
+                   and tp.__name__ == "Collection"
+                   for tp in type(self).__mro__):
+                props.append("alpha")
+            for other in props:
+                if other not in keys:
+                    continue
+                i_other = keys.index(other)
+                if i_other < i_color:
+                    move_color_to_start = True
+                    cbook.warn_deprecated(
+                        "3.3", message=f"You have passed the {other!r} kwarg "
+                        "before the 'color' kwarg.  Artist.set() currently "
+                        "reorders the properties to apply 'color' first, but "
+                        "this is deprecated since %(since)s and will be "
+                        "removed %(removal)s; please pass 'color' first "
+                        "instead.")
+        if move_color_to_start:
+            kwargs = {"color": kwargs.pop("color"), **kwargs}
+        return self.update(kwargs)
 
     def findobj(self, match=None, include_self=True):
         """
diff --git a/lib/matplotlib/cbook/__init__.py b/lib/matplotlib/cbook/__init__.py
@@ -1771,43 +1771,19 @@ def normalize_kwargs(kw, alias_mapping=None, required=(), forbidden=(),
           or isinstance(alias_mapping, Artist)):
         alias_mapping = getattr(alias_mapping, "_alias_map", {})
 
-    # make a local so we can pop
-    kw = dict(kw)
-    # output dictionary
-    ret = dict()
-
-    # hit all alias mappings
-    for canonical, alias_list in alias_mapping.items():
-
-        # the alias lists are ordered from lowest to highest priority
-        # so we know to use the last value in this list
-        tmp = []
-        seen = []
-        for a in alias_list:
-            try:
-                tmp.append(kw.pop(a))
-                seen.append(a)
-            except KeyError:
-                pass
-        # if canonical is not in the alias_list assume highest priority
-        if canonical not in alias_list:
-            try:
-                tmp.append(kw.pop(canonical))
-                seen.append(canonical)
-            except KeyError:
-                pass
-        # if we found anything in this set of aliases put it in the return
-        # dict
-        if tmp:
-            ret[canonical] = tmp[-1]
-            if len(tmp) > 1:
-                raise TypeError("Got the following keyword arguments which "
-                                "are aliases of one another: {}"
-                                .format(", ".join(map(repr, seen))))
-
-    # at this point we know that all keys which are aliased are removed, update
-    # the return dictionary from the cleaned local copy of the input
-    ret.update(kw)
+    to_canonical = {alias: canonical
+                    for canonical, alias_list in alias_mapping.items()
+                    for alias in alias_list}
+    canonical_to_seen = {}
+    ret = {}  # output dictionary
+
+    for k, v in kw.items():
+        canonical = to_canonical.get(k, k)
+        if canonical in canonical_to_seen:
+            raise TypeError(f"Got both {canonical_to_seen[canonical]!r} and "
+                            f"{k!r}, which are aliases of one another")
+        canonical_to_seen[canonical] = k
+        ret[canonical] = v
 
     fail_keys = [k for k in required if k not in ret]
     if fail_keys:
