ENH: remove arbitrary long args if used with data

jankatins · jankatins · commit b4f011c570fa · 2015-08-31T12:06:52.000+02:00
Arbitrary long args, i.e., plot("x","y","r","x2","y2","b") were problematic if used with a data kwarg and the color spec ("r", "b") was included in data: this made it impossible in some cases to determine what the user wanted to plot: plot("x","y","r","x2","y2","b", data={..., "r":..., "b":...) could be interpreted as plot(x, y, "r") # all points red plot(x2, y2, "b") # all points black or plot(x,y) plot(r,x2) plot(y2,b) This could lead to hard to debug problems if both styles result in a similar plot (e.g. if all are values in the same range). Therefore it was decided to remove this possibility so that the usere gets a proper error message instead: #4829 (comment) There is still a case of ambiguity (plot("y", "ro", data={"y":..., "ro":...), which is now detected and a warning is issued. This detection could theoretically be used to detect the above case as well, but there were so many corner cases, that the checks became too horrible and I took that out again. Note that passing in data directly (without a data kwarg) is unaffected, it still accepts arbitrary long args.
diff --git a/lib/matplotlib/axes/_axes.py b/lib/matplotlib/axes/_axes.py
@@ -49,42 +49,48 @@
 
 
 def _plot_args_replacer(args, data):
-    _replacer = []
-    remaining = args
-    while 1:
-        if len(remaining) == 1:
-
-            msg = ("Missing argument: this can happen if a color spec "
-                   "('c') is in `data`")
-            warnings.warn(msg, RuntimeWarning, stacklevel=3)
-            _replacer += ["x"]
-        elif len(remaining) == 2:
-            _replacer += ["x", "y"]
-        elif len(remaining) == 3:
-            if remaining[2] in data:
+    if len(args) == 1:
+        return ["y"]
+    elif len(args) == 2:
+        # this can be two cases: x,y or y,c
+        if not args[1] in data:
+            # this is not in data, so just assume that it is something which
+            # will not get replaced (color spec or array like).
+            return ["y", "c"]
+        # it's data, but could be a color code like 'ro' or 'b--'
+        # -> warn the user in that case...
+        arg2 = args[1]
+        if is_string_like(arg2) and len(arg2) <= 3:
+            # all possible linestyles and color codes -> see doc of plot
+            reserved_ls = ["-", "--", "-.", ":", ".", ",", "o", "v", "^", "<",
+                           ">", "1", "2", "3", "4", "s", "p", "*", "h", "H",
+                           "+", "x", "D", "d", "|", "_"]
+            reserved_cc = ["b", "r", "c", "m", "y", "k", "w"]
+            # remove the line style part
+            for ls in reserved_ls:
+                if ls in arg2:
+                    arg2 = arg2.replace(ls, '')
+                    continue
+            # can now only be a color code...
+            if arg2 in reserved_cc:
                 import warnings
-
-                msg = "Found a color spec ('c') in data."
+                msg = "Second argument is ambiguous: could be a color spec " \
+                      "but is in data. Using as data.\nEither rename the " \
+                      "entry in data or use three arguments to plot."
                 warnings.warn(msg, RuntimeWarning, stacklevel=3)
-            _replacer += ["x", "y", "c"]
-
-        # if less than 3, the above code handled it so just return
-        if len(remaining) <= 3:
-            return _replacer
-
-        # More than 3 -> split off the beginning and continue
-        if remaining[2] not in data:
-            _replacer += ["x", "y", "c"]
-            isplit = 3
-        else:
-            _replacer += ["x", "y"]
-            isplit = 2
-        remaining = remaining[isplit:]
+        return ["x", "y"]
+    elif len(args) == 3:
+        return ["x", "y", "c"]
+    else:
+        raise ValueError("Using arbitrary long args with data is not "
+                         "supported due to ambiguity of arguments.\nUse "
+                         "multiple plotting calls instead.")
 
 
 # The axes module contains all the wrappers to plotting functions.
 # All the other methods should go in the _AxesBase class.
 
+
 class Axes(_AxesBase):
     """
     The :class:`Axes` contains most of the figure elements:
@@ -1305,8 +1311,14 @@ def plot(self, *args, **kwargs):
         If *x* and/or *y* is 2-dimensional, then the corresponding columns
         will be plotted.
 
-        An arbitrary number of *x*, *y*, *fmt* groups can be
-        specified, as in::
+        If used with labeled data, make sure that the color spec is not
+        included as an element in data, as otherwise the last case
+        ``plot("v","r", data={"v":..., "r":...)``
+        can be interpreted as the first case which would do ``plot(v, r)``
+        using the default line style and color.
+
+        If not used with labeled data (i.e., without a data argument),
+        an arbitrary number of *x*, *y*, *fmt* groups can be specified, as in::
 
             a.plot(x1, y1, 'g^', x2, y2, 'g-')
 
diff --git a/lib/matplotlib/tests/test_labeled_data_unpacking.py b/lib/matplotlib/tests/test_labeled_data_unpacking.py
@@ -467,31 +467,27 @@ def test_positional_parameter_names_as_function():
     # Also test the _plot_arg_replacer for plot...
     from matplotlib.axes._axes import _plot_args_replacer
 
-    # this is a replace for plot, which can take args as
-    # x,y,c,x,y,c or x,y,x,y,c,x,y or any other way... :-/
     @unpack_labeled_data(replace_names=["x", "y"],
                          positional_parameter_names=_plot_args_replacer)
     def funcy(ax, *args, **kwargs):
         return "{args} | {kwargs}".format(args=args, kwargs=kwargs)
 
+    # the normal case...
     data = {"x": "X", "y": "Y"}
     assert_equal(funcy(None, "x", "y", data=data),
                  "('X', 'Y') | {}")
     assert_equal(funcy(None, "x", "y", "c", data=data),
                  "('X', 'Y', 'c') | {}")
-    assert_equal(funcy(None, "x", "y", "c", "x", "y", "x", "y", data=data),
-                 "('X', 'Y', 'c', 'X', 'Y', 'X', 'Y') | {}")
 
-    # the color spec should not be in data...
-    data = {"x": "X", "y": "Y", "c": "!!"}
-    with assert_produces_warning(RuntimeWarning):
+    # no arbitrary long args with data
+    def f():
         assert_equal(funcy(None, "x", "y", "c", "x", "y", "x", "y", data=data),
-                     "('X', 'Y', '!!', 'X', 'Y', 'X', 'y') | {}")
-
-    # And this is the case which we screw up, as we can't distinguish
-    # between a color spec and data...
-    # -> This test should actually produce a warning, if someone finds a way
-    # to distinguish between data and color spec...
-    with assert_produces_warning(False):
-        assert_equal(funcy(None, "x", "y", "c", "x", "y", "c", data=data),
-                     "('X', 'Y', '!!', 'X', 'Y', '!!') | {}")
+                     "('X', 'Y', 'c', 'X', 'Y', 'X', 'Y') | {}")
+    assert_raises(ValueError, f)
+
+    # In the two arg case, if a valid color spec is in data, we warn but use
+    # it as data...
+    data = {"x": "X", "y": "Y", "ro": "!!"}
+    with assert_produces_warning(RuntimeWarning):
+        assert_equal(funcy(None, "y", "ro", data=data),
+                     "('Y', '!!') | {}")
