Merge pull request matplotlib#22058 from dstansby/mplot3d-depr

API: Remove exprired mplot3d deprecations for 3.6

Author: tacaswell

doc/api/next_api_changes/removals/00001-DS.rst

@@ -0,0 +1,28 @@
+Removal of mplot3d deprecations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The deprecated ``renderer`` arguments have been removed from:
+
+- `.Line3DCollection.do_3d_projection`
+- `.Patch3D.do_3d_projection`
+- `.PathPatch3D.do_3d_projection`
+- `.Path3DCollection.do_3d_projection`
+- `.Patch3DCollection.do_3d_projection`
+- `.Poly3DCollection.do_3d_projection`
+
+The deprecated ``project`` argument has also been removed from
+``Line3DCollection.draw()``.
+
+Passing arguments not specifically listed in the signatures of
+`.Axes3D.plot_surface` and `.Axes3D.plot_wireframe` is no longer supported.
+Pass any extra arguments as keyword arguments instead.
+
+These properties of the 3D Axes that were placed on the Renderer during draw
+have been removed:
+
+* ``renderer.M``
+* ``renderer.eye``
+* ``renderer.vvec``
+* ``renderer.get_axis_position``
+
+These attributes are all available via `.Axes3D`, which can be accessed via
+``self.axes`` on all `.Artist`\s.

lib/mpl_toolkits/mplot3d/art3d.py

@@ -12,8 +12,7 @@
 import numpy as np
 
 from matplotlib import (
-    _api, artist, cbook, colors as mcolors, lines, text as mtext,
-    path as mpath)
+    artist, cbook, colors as mcolors, lines, text as mtext, path as mpath)
 from matplotlib.collections import (
     LineCollection, PolyCollection, PatchCollection, PathCollection)
 from matplotlib.colors import Normalize
@@ -297,8 +296,7 @@ def set_segments(self, segments):
         self._segments3d = segments
         super().set_segments([])
 
-    @_api.delete_parameter('3.4', 'renderer')
-    def do_3d_projection(self, renderer=None):
+    def do_3d_projection(self):
         """
         Project the points according to renderer matrix.
         """
@@ -313,14 +311,6 @@ def do_3d_projection(self, renderer=None):
             minz = min(minz, min(zs))
         return minz
 
-    @artist.allow_rasterization
-    @_api.delete_parameter('3.4', 'project',
-                           alternative='Line3DCollection.do_3d_projection')
-    def draw(self, renderer, project=False):
-        if project:
-            self.do_3d_projection()
-        super().draw(renderer)
-
 
 def line_collection_2d_to_3d(col, zs=0, zdir='z'):
     """Convert a LineCollection to a Line3DCollection object."""
@@ -346,8 +336,7 @@ def set_3d_properties(self, verts, zs=0, zdir='z'):
     def get_path(self):
         return self._path2d
 
-    @_api.delete_parameter('3.4', 'renderer')
-    def do_3d_projection(self, renderer=None):
+    def do_3d_projection(self):
         s = self._segment3d
         xs, ys, zs = zip(*s)
         vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
@@ -370,8 +359,7 @@ def set_3d_properties(self, path, zs=0, zdir='z'):
         Patch3D.set_3d_properties(self, path.vertices, zs=zs, zdir=zdir)
         self._code3d = path.codes
 
-    @_api.delete_parameter('3.4', 'renderer')
-    def do_3d_projection(self, renderer=None):
+    def do_3d_projection(self):
         s = self._segment3d
         xs, ys, zs = zip(*s)
         vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
@@ -466,8 +454,7 @@ def set_3d_properties(self, zs, zdir):
         self._vzs = None
         self.stale = True
 
-    @_api.delete_parameter('3.4', 'renderer')
-    def do_3d_projection(self, renderer=None):
+    def do_3d_projection(self):
         xs, ys, zs = self._offsets3d
         vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
                                                         self.axes.M)
@@ -594,8 +581,7 @@ def set_depthshade(self, depthshade):
         self._depthshade = depthshade
         self.stale = True
 
-    @_api.delete_parameter('3.4', 'renderer')
-    def do_3d_projection(self, renderer=None):
+    def do_3d_projection(self):
         xs, ys, zs = self._offsets3d
         vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
                                                         self.axes.M)
@@ -786,8 +772,7 @@ def set_sort_zpos(self, val):
         self._sort_zpos = val
         self.stale = True
 
-    @_api.delete_parameter('3.4', 'renderer')
-    def do_3d_projection(self, renderer=None):
+    def do_3d_projection(self):
         """
         Perform the 3D projection for this object.
         """

lib/mpl_toolkits/mplot3d/axes3d.py

@@ -12,7 +12,6 @@
 
 from collections import defaultdict
 import functools
-import inspect
 import itertools
 import math
 from numbers import Integral
@@ -405,82 +404,41 @@ def draw(self, renderer):
 
         # add the projection matrix to the renderer
         self.M = self.get_proj()
-        props3d = {
-            # To raise a deprecation, we need to wrap the attribute in a
-            # function, but binding that to an instance does not work, as you
-            # would end up with an instance-specific method. Properties are
-            # class-level attributes which *are* functions, so we do that
-            # instead.
-            # This dictionary comprehension creates deprecated properties for
-            # the attributes listed below, and they are temporarily attached to
-            # the _class_ in the `_setattr_cm` call. These can both be removed
-            # once the deprecation expires
-            name: _api.deprecated('3.4', name=name,
-                                  alternative=f'self.axes.{name}')(
-                property(lambda self, _value=getattr(self, name): _value))
-            for name in ['M', 'vvec', 'eye', 'get_axis_position']
-        }
-
-        with cbook._setattr_cm(type(renderer), **props3d):
-            def do_3d_projection(artist):
-                """
-                Call `do_3d_projection` on an *artist*, and warn if passing
-                *renderer*.
-
-                Attempt to bind the empty signature first, so external Artists
-                can avoid the deprecation warning if they support the new
-                calling convention.
-                """
-                try:
-                    signature = inspect.signature(artist.do_3d_projection)
-                    signature.bind()
-                # ValueError if `inspect.signature` cannot provide a signature
-                # and TypeError if the binding fails or the object does not
-                # appear to be callable - the next call will then re-raise.
-                except (ValueError, TypeError):
-                    _api.warn_deprecated(
-                        "3.4",
-                        message="The 'renderer' parameter of "
-                        "do_3d_projection() was deprecated in Matplotlib "
-                        "%(since)s and will be removed %(removal)s.")
-                    return artist.do_3d_projection(renderer)
-                else:
-                    # Call this directly once the deprecation period expires.
-                    return artist.do_3d_projection()
-
-            collections_and_patches = (
-                artist for artist in self._children
-                if isinstance(artist, (mcoll.Collection, mpatches.Patch))
-                and artist.get_visible())
-            if self.computed_zorder:
-                # Calculate projection of collections and patches and zorder
-                # them. Make sure they are drawn above the grids.
-                zorder_offset = max(axis.get_zorder()
-                                    for axis in self._get_axis_list()) + 1
-                collection_zorder = patch_zorder = zorder_offset
-                for artist in sorted(collections_and_patches,
-                                     key=do_3d_projection,
-                                     reverse=True):
-                    if isinstance(artist, mcoll.Collection):
-                        artist.zorder = collection_zorder
-                        collection_zorder += 1
-                    elif isinstance(artist, mpatches.Patch):
-                        artist.zorder = patch_zorder
-                        patch_zorder += 1
-            else:
-                for artist in collections_and_patches:
-                    artist.do_3d_projection()
 
-            if self._axis3don:
-                # Draw panes first
-                for axis in self._get_axis_list():
-                    axis.draw_pane(renderer)
-                # Then axes
-                for axis in self._get_axis_list():
-                    axis.draw(renderer)
+        collections_and_patches = (
+            artist for artist in self._children
+            if isinstance(artist, (mcoll.Collection, mpatches.Patch))
+            and artist.get_visible())
+        if self.computed_zorder:
+            # Calculate projection of collections and patches and zorder
+            # them. Make sure they are drawn above the grids.
+            zorder_offset = max(axis.get_zorder()
+                                for axis in self._get_axis_list()) + 1
+            collection_zorder = patch_zorder = zorder_offset
+
+            for artist in sorted(collections_and_patches,
+                                 key=lambda artist: artist.do_3d_projection(),
+                                 reverse=True):
+                if isinstance(artist, mcoll.Collection):
+                    artist.zorder = collection_zorder
+                    collection_zorder += 1
+                elif isinstance(artist, mpatches.Patch):
+                    artist.zorder = patch_zorder
+                    patch_zorder += 1
+        else:
+            for artist in collections_and_patches:
+                artist.do_3d_projection()
+
+        if self._axis3don:
+            # Draw panes first
+            for axis in self._get_axis_list():
+                axis.draw_pane(renderer)
+            # Then axes
+            for axis in self._get_axis_list():
+                axis.draw(renderer)
 
-            # Then rest
-            super().draw(renderer)
+        # Then rest
+        super().draw(renderer)
 
     def get_axis_position(self):
         vals = self.get_w_lims()
@@ -1504,8 +1462,7 @@ def plot(self, xs, ys, *args, zdir='z', **kwargs):
 
     plot3D = plot
 
-    @_api.delete_parameter("3.4", "args", alternative="kwargs")
-    def plot_surface(self, X, Y, Z, *args, norm=None, vmin=None,
+    def plot_surface(self, X, Y, Z, *, norm=None, vmin=None,
                      vmax=None, lightsource=None, **kwargs):
         """
         Create a surface plot.
@@ -1679,7 +1636,7 @@ def plot_surface(self, X, Y, Z, *args, norm=None, vmin=None,
 
         # note that the striding causes some polygons to have more coordinates
         # than others
-        polyc = art3d.Poly3DCollection(polys, *args, **kwargs)
+        polyc = art3d.Poly3DCollection(polys, **kwargs)
 
         if fcolors is not None:
             if shade:
@@ -1790,8 +1747,7 @@ def norm(x):
 
         return colors
 
-    @_api.delete_parameter("3.4", "args", alternative="kwargs")
-    def plot_wireframe(self, X, Y, Z, *args, **kwargs):
+    def plot_wireframe(self, X, Y, Z, **kwargs):
         """
         Plot a 3D wireframe.
 
@@ -1903,7 +1859,7 @@ def plot_wireframe(self, X, Y, Z, *args, **kwargs):
                  + [list(zip(xl, yl, zl))
                  for xl, yl, zl in zip(txlines, tylines, tzlines)])
 
-        linec = art3d.Line3DCollection(lines, *args, **kwargs)
+        linec = art3d.Line3DCollection(lines, **kwargs)
         self.add_collection(linec)
         self.auto_scale_xyz(X, Y, Z, had_data)
 

lib/mpl_toolkits/tests/test_mplot3d.py

@@ -1713,63 +1713,3 @@ def test_view_init_vertical_axis(
         tickdir_expected = tickdirs_expected[i]
         tickdir_actual = axis._get_tickdir()
         np.testing.assert_array_equal(tickdir_expected, tickdir_actual)
-
-
-def test_do_3d_projection_renderer_deprecation_warn_on_argument():
-    """
-    Test that an external artist with an old-style calling convention raises
-    a suitable deprecation warning.
-    """
-    class DummyPatch(art3d.Patch3D):
-        def do_3d_projection(self, renderer):
-            return 0
-
-        def draw(self, renderer):
-            pass
-
-    fig = plt.figure()
-    ax = fig.add_subplot(111, projection='3d')
-    artist = DummyPatch()
-    ax.add_artist(artist)
-
-    match = r"The 'renderer' parameter of do_3d_projection\(\) was deprecated"
-    with pytest.warns(MatplotlibDeprecationWarning, match=match):
-        fig.canvas.draw()
-
-
-def test_do_3d_projection_renderer_deprecation_nowarn_on_optional_argument():
-    """
-    Test that an external artist with a calling convention compatible with
-    both v3.3 and v3.4 does not raise a deprecation warning.
-    """
-    class DummyPatch(art3d.Patch3D):
-        def do_3d_projection(self, renderer=None):
-            return 0
-
-        def draw(self, renderer):
-            pass
-
-    fig = plt.figure()
-    ax = fig.add_subplot(111, projection='3d')
-    artist = DummyPatch()
-    ax.add_artist(artist)
-    fig.canvas.draw()
-
-
-def test_do_3d_projection_renderer_deprecation_nowarn_on_no_argument():
-    """
-    Test that an external artist with a calling convention compatible with
-    only v3.4 does not raise a deprecation warning.
-    """
-    class DummyPatch(art3d.Patch3D):
-        def do_3d_projection(self):
-            return 0
-
-        def draw(self, renderer):
-            pass
-
-    fig = plt.figure()
-    ax = fig.add_subplot(111, projection='3d')
-    artist = DummyPatch()
-    ax.add_artist(artist)
-    fig.canvas.draw()