Make Scale axis parameter handling more flexible

Instead of checking the types ourselves, try to bind the old signature,
if possible, then use it. Otherwise, try to use the new signature. This
is similar to `_api.select_matching_signature` without needing to write
a callable for each signature.

Author: QuLogic

lib/matplotlib/scale.py

@@ -170,12 +170,16 @@ def _make_axis_parameter_optional(init_func):
     """
     @wraps(init_func)
     def wrapper(self, *args, **kwargs):
-        if args and isinstance(args[0], mpl.axis.Axis):
-            return init_func(self, *args, **kwargs)
+        sig = inspect.signature(init_func)
+        try:
+            # Try old signature.
+            sig.bind(self, *args, **kwargs)
+        except TypeError:
+            # Use the new signature and pass in an unused axis=None.
+            init_func(self, None, *args, **kwargs)
         else:
-            # Remove 'axis' from kwargs to avoid double assignment
-            axis = kwargs.pop('axis', None)
-            return init_func(self, axis, *args, **kwargs)
+            # Use the old signature.
+            init_func(self, *args, **kwargs)
     return wrapper
 
 

lib/matplotlib/tests/test_scale.py

@@ -3,6 +3,7 @@
 import matplotlib.pyplot as plt
 from matplotlib.scale import (
     AsinhScale, AsinhTransform,
+    FuncScale, LogitScale,
     LogTransform, InvertedLogTransform,
     SymmetricalLogTransform)
 import matplotlib.scale as mscale
@@ -19,6 +20,46 @@
 import pytest
 
 
+def test_optional_axis_signature():
+    # There are three types of original signatures possible, and this only tests one
+    # example class of each:
+    # 1. `axis` without default: LinearScale, FuncScale, FuncScaleLog
+    # 2. `axis` with default and more positional parameters: LogitScale
+    # 3. `axis` with default and only keyword-only parameters: LogScale, AsinhScale,
+    #    SymmetricalLogScale
+
+    # Old signature with axis positionally.
+    FuncScale(None, (lambda x: x, lambda x: x))
+    FuncScale(None, functions=(lambda x: x, lambda x: x))
+    LogitScale(None)
+    LogitScale(None, 'clip')
+    LogitScale(None, nonpositive='clip')
+    LogitScale(None, use_overline=True)
+    AsinhScale(None)
+    AsinhScale(None, linear_width=2)
+    AsinhScale(None, base=3)
+    AsinhScale(None, subs=[2, 6])
+    # Old signature with axis as keyword.
+    FuncScale(axis=None, functions=(lambda x: x, lambda x: x))
+    LogitScale(axis=None)
+    LogitScale(axis=None, nonpositive='clip')
+    LogitScale(axis=None, use_overline=True)
+    AsinhScale(axis=None)
+    AsinhScale(axis=None, linear_width=2)
+    AsinhScale(axis=None, base=3)
+    AsinhScale(axis=None, subs=[2, 6])
+    # New signature without axis.
+    FuncScale((lambda x: x, lambda x: x))
+    FuncScale(functions=(lambda x: x, lambda x: x))
+    LogitScale()
+    LogitScale(nonpositive='clip')
+    LogitScale(use_overline=True)
+    AsinhScale()
+    AsinhScale(linear_width=2)
+    AsinhScale(base=3)
+    AsinhScale(subs=[2, 6])
+
+
 @check_figures_equal()
 def test_log_scales(fig_test, fig_ref):
     ax_test = fig_test.add_subplot(122, yscale='log', xscale='symlog')