Fixed database typo and removed unnecessary class identifier.

venv/Lib/site-packages/mpl_toolkits/tests/__init__.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+
+# Check that the test directories exist
+if not (Path(__file__).parent / "baseline_images").exists():
+    raise IOError(
+        'The baseline image directory does not exist. '
+        'This is most likely because the test data is not installed. '
+        'You may need to install matplotlib from source to get the '
+        'test data.')

venv/Lib/site-packages/mpl_toolkits/tests/conftest.py

@@ -0,0 +1,3 @@
+from matplotlib.testing.conftest import (mpl_test_settings,
+                                         mpl_image_comparison_parameters,
+                                         pytest_configure, pytest_unconfigure)

venv/Lib/site-packages/mpl_toolkits/tests/test_axes_grid.py

@@ -0,0 +1,63 @@
+from contextlib import ExitStack
+
+import numpy as np
+import pytest
+
+import matplotlib as mpl
+from matplotlib.testing.decorators import image_comparison
+import matplotlib.pyplot as plt
+from mpl_toolkits.axes_grid1 import ImageGrid
+
+
+# The original version of this test relied on mpl_toolkits's slightly different
+# colorbar implementation; moving to matplotlib's own colorbar implementation
+# caused the small image comparison error.
+@pytest.mark.parametrize("legacy_colorbar", [False, True])
+@image_comparison(['imagegrid_cbar_mode.png'],
+                  remove_text=True, style='mpl20', tol=0.3)
+def test_imagegrid_cbar_mode_edge(legacy_colorbar):
+    mpl.rcParams["mpl_toolkits.legacy_colorbar"] = legacy_colorbar
+
+    X, Y = np.meshgrid(np.linspace(0, 6, 30), np.linspace(0, 6, 30))
+    arr = np.sin(X) * np.cos(Y) + 1j*(np.sin(3*Y) * np.cos(Y/2.))
+
+    fig = plt.figure(figsize=(18, 9))
+
+    positions = (241, 242, 243, 244, 245, 246, 247, 248)
+    directions = ['row']*4 + ['column']*4
+    cbar_locations = ['left', 'right', 'top', 'bottom']*2
+
+    for position, direction, location in zip(
+            positions, directions, cbar_locations):
+        grid = ImageGrid(fig, position,
+                         nrows_ncols=(2, 2),
+                         direction=direction,
+                         cbar_location=location,
+                         cbar_size='20%',
+                         cbar_mode='edge')
+        ax1, ax2, ax3, ax4, = grid
+
+        ax1.imshow(arr.real, cmap='nipy_spectral')
+        ax2.imshow(arr.imag, cmap='hot')
+        ax3.imshow(np.abs(arr), cmap='jet')
+        ax4.imshow(np.arctan2(arr.imag, arr.real), cmap='hsv')
+
+        with (pytest.warns(mpl.MatplotlibDeprecationWarning) if legacy_colorbar
+              else ExitStack()):
+            # In each row/column, the "first" colorbars must be overwritten by
+            # the "second" ones.  To achieve this, clear out the axes first.
+            for ax in grid:
+                ax.cax.cla()
+                cb = ax.cax.colorbar(
+                    ax.images[0],
+                    ticks=mpl.ticker.MaxNLocator(5))  # old default locator.
+
+
+def test_imagegrid():
+    mpl.rcParams["mpl_toolkits.legacy_colorbar"] = False
+    fig = plt.figure()
+    grid = ImageGrid(fig, 111, nrows_ncols=(1, 1))
+    ax = grid[0]
+    im = ax.imshow([[1, 2]], norm=mpl.colors.LogNorm())
+    cb = ax.cax.colorbar(im)
+    assert isinstance(cb.locator, mpl.colorbar._ColorbarLogLocator)

venv/Lib/site-packages/mpl_toolkits/tests/test_axes_grid1.py

@@ -0,0 +1,480 @@
+from itertools import product
+import platform
+
+import matplotlib
+import matplotlib.pyplot as plt
+from matplotlib import cbook
+from matplotlib.cbook import MatplotlibDeprecationWarning
+from matplotlib.backend_bases import MouseEvent
+from matplotlib.colors import LogNorm
+from matplotlib.transforms import Bbox, TransformedBbox
+from matplotlib.testing.decorators import (
+    image_comparison, remove_ticks_and_titles)
+
+from mpl_toolkits.axes_grid1 import (
+    axes_size as Size, host_subplot, make_axes_locatable, AxesGrid, ImageGrid)
+from mpl_toolkits.axes_grid1.anchored_artists import (
+    AnchoredSizeBar, AnchoredDirectionArrows)
+from mpl_toolkits.axes_grid1.axes_divider import HBoxDivider
+from mpl_toolkits.axes_grid1.inset_locator import (
+    zoomed_inset_axes, mark_inset, inset_axes, BboxConnectorPatch)
+import mpl_toolkits.axes_grid1.mpl_axes
+
+import pytest
+
+import numpy as np
+from numpy.testing import assert_array_equal, assert_array_almost_equal
+
+
+def test_divider_append_axes():
+    fig, ax = plt.subplots()
+    divider = make_axes_locatable(ax)
+    axs = {
+        "main": ax,
+        "top": divider.append_axes("top", 1.2, pad=0.1, sharex=ax),
+        "bottom": divider.append_axes("bottom", 1.2, pad=0.1, sharex=ax),
+        "left": divider.append_axes("left", 1.2, pad=0.1, sharey=ax),
+        "right": divider.append_axes("right", 1.2, pad=0.1, sharey=ax),
+    }
+    fig.canvas.draw()
+    renderer = fig.canvas.get_renderer()
+    bboxes = {k: axs[k].get_window_extent() for k in axs}
+    dpi = fig.dpi
+    assert bboxes["top"].height == pytest.approx(1.2 * dpi)
+    assert bboxes["bottom"].height == pytest.approx(1.2 * dpi)
+    assert bboxes["left"].width == pytest.approx(1.2 * dpi)
+    assert bboxes["right"].width == pytest.approx(1.2 * dpi)
+    assert bboxes["top"].y0 - bboxes["main"].y1 == pytest.approx(0.1 * dpi)
+    assert bboxes["main"].y0 - bboxes["bottom"].y1 == pytest.approx(0.1 * dpi)
+    assert bboxes["main"].x0 - bboxes["left"].x1 == pytest.approx(0.1 * dpi)
+    assert bboxes["right"].x0 - bboxes["main"].x1 == pytest.approx(0.1 * dpi)
+    assert bboxes["left"].y0 == bboxes["main"].y0 == bboxes["right"].y0
+    assert bboxes["left"].y1 == bboxes["main"].y1 == bboxes["right"].y1
+    assert bboxes["top"].x0 == bboxes["main"].x0 == bboxes["bottom"].x0
+    assert bboxes["top"].x1 == bboxes["main"].x1 == bboxes["bottom"].x1
+
+
+@image_comparison(['twin_axes_empty_and_removed'], extensions=["png"], tol=1)
+def test_twin_axes_empty_and_removed():
+    # Purely cosmetic font changes (avoid overlap)
+    matplotlib.rcParams.update({"font.size": 8})
+    matplotlib.rcParams.update({"xtick.labelsize": 8})
+    matplotlib.rcParams.update({"ytick.labelsize": 8})
+    generators = ["twinx", "twiny", "twin"]
+    modifiers = ["", "host invisible", "twin removed", "twin invisible",
+                 "twin removed\nhost invisible"]
+    # Unmodified host subplot at the beginning for reference
+    h = host_subplot(len(modifiers)+1, len(generators), 2)
+    h.text(0.5, 0.5, "host_subplot",
+           horizontalalignment="center", verticalalignment="center")
+    # Host subplots with various modifications (twin*, visibility) applied
+    for i, (mod, gen) in enumerate(product(modifiers, generators),
+                                   len(generators) + 1):
+        h = host_subplot(len(modifiers)+1, len(generators), i)
+        t = getattr(h, gen)()
+        if "twin invisible" in mod:
+            t.axis[:].set_visible(False)
+        if "twin removed" in mod:
+            t.remove()
+        if "host invisible" in mod:
+            h.axis[:].set_visible(False)
+        h.text(0.5, 0.5, gen + ("\n" + mod if mod else ""),
+               horizontalalignment="center", verticalalignment="center")
+    plt.subplots_adjust(wspace=0.5, hspace=1)
+
+
+@pytest.mark.parametrize("legacy_colorbar", [False, True])
+def test_axesgrid_colorbar_log_smoketest(legacy_colorbar):
+    matplotlib.rcParams["mpl_toolkits.legacy_colorbar"] = legacy_colorbar
+
+    fig = plt.figure()
+    grid = AxesGrid(fig, 111,  # modified to be only subplot
+                    nrows_ncols=(1, 1),
+                    ngrids=1,
+                    label_mode="L",
+                    cbar_location="top",
+                    cbar_mode="single",
+                    )
+
+    Z = 10000 * np.random.rand(10, 10)
+    im = grid[0].imshow(Z, interpolation="nearest", norm=LogNorm())
+
+    if legacy_colorbar:
+        with pytest.warns(MatplotlibDeprecationWarning):
+            grid.cbar_axes[0].colorbar(im)
+    else:
+        grid.cbar_axes[0].colorbar(im)
+
+
+@image_comparison(['inset_locator.png'], style='default', remove_text=True)
+def test_inset_locator():
+    fig, ax = plt.subplots(figsize=[5, 4])
+
+    # prepare the demo image
+    # Z is a 15x15 array
+    Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy", np_load=True)
+    extent = (-3, 4, -4, 3)
+    Z2 = np.zeros((150, 150))
+    ny, nx = Z.shape
+    Z2[30:30+ny, 30:30+nx] = Z
+
+    # extent = [-3, 4, -4, 3]
+    ax.imshow(Z2, extent=extent, interpolation="nearest",
+              origin="lower")
+
+    axins = zoomed_inset_axes(ax, zoom=6, loc='upper right')
+    axins.imshow(Z2, extent=extent, interpolation="nearest",
+                 origin="lower")
+    axins.yaxis.get_major_locator().set_params(nbins=7)
+    axins.xaxis.get_major_locator().set_params(nbins=7)
+    # sub region of the original image
+    x1, x2, y1, y2 = -1.5, -0.9, -2.5, -1.9
+    axins.set_xlim(x1, x2)
+    axins.set_ylim(y1, y2)
+
+    plt.xticks(visible=False)
+    plt.yticks(visible=False)
+
+    # draw a bbox of the region of the inset axes in the parent axes and
+    # connecting lines between the bbox and the inset axes area
+    mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5")
+
+    asb = AnchoredSizeBar(ax.transData,
+                          0.5,
+                          '0.5',
+                          loc='lower center',
+                          pad=0.1, borderpad=0.5, sep=5,
+                          frameon=False)
+    ax.add_artist(asb)
+
+
+@image_comparison(['inset_axes.png'], style='default', remove_text=True)
+def test_inset_axes():
+    fig, ax = plt.subplots(figsize=[5, 4])
+
+    # prepare the demo image
+    # Z is a 15x15 array
+    Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy", np_load=True)
+    extent = (-3, 4, -4, 3)
+    Z2 = np.zeros((150, 150))
+    ny, nx = Z.shape
+    Z2[30:30+ny, 30:30+nx] = Z
+
+    # extent = [-3, 4, -4, 3]
+    ax.imshow(Z2, extent=extent, interpolation="nearest",
+              origin="lower")
+
+    # creating our inset axes with a bbox_transform parameter
+    axins = inset_axes(ax, width=1., height=1., bbox_to_anchor=(1, 1),
+                       bbox_transform=ax.transAxes)
+
+    axins.imshow(Z2, extent=extent, interpolation="nearest",
+                 origin="lower")
+    axins.yaxis.get_major_locator().set_params(nbins=7)
+    axins.xaxis.get_major_locator().set_params(nbins=7)
+    # sub region of the original image
+    x1, x2, y1, y2 = -1.5, -0.9, -2.5, -1.9
+    axins.set_xlim(x1, x2)
+    axins.set_ylim(y1, y2)
+
+    plt.xticks(visible=False)
+    plt.yticks(visible=False)
+
+    # draw a bbox of the region of the inset axes in the parent axes and
+    # connecting lines between the bbox and the inset axes area
+    mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5")
+
+    asb = AnchoredSizeBar(ax.transData,
+                          0.5,
+                          '0.5',
+                          loc='lower center',
+                          pad=0.1, borderpad=0.5, sep=5,
+                          frameon=False)
+    ax.add_artist(asb)
+
+
+def test_inset_axes_complete():
+    dpi = 100
+    figsize = (6, 5)
+    fig, ax = plt.subplots(figsize=figsize, dpi=dpi)
+    fig.subplots_adjust(.1, .1, .9, .9)
+
+    ins = inset_axes(ax, width=2., height=2., borderpad=0)
+    fig.canvas.draw()
+    assert_array_almost_equal(
+            ins.get_position().extents,
+            np.array(((0.9*figsize[0]-2.)/figsize[0],
+                      (0.9*figsize[1]-2.)/figsize[1], 0.9, 0.9)))
+
+    ins = inset_axes(ax, width="40%", height="30%", borderpad=0)
+    fig.canvas.draw()
+    assert_array_almost_equal(
+            ins.get_position().extents,
+            np.array((.9-.8*.4, .9-.8*.3, 0.9, 0.9)))
+
+    ins = inset_axes(ax, width=1., height=1.2, bbox_to_anchor=(200, 100),
+                     loc=3, borderpad=0)
+    fig.canvas.draw()
+    assert_array_almost_equal(
+            ins.get_position().extents,
+            np.array((200./dpi/figsize[0], 100./dpi/figsize[1],
+                     (200./dpi+1)/figsize[0], (100./dpi+1.2)/figsize[1])))
+
+    ins1 = inset_axes(ax, width="35%", height="60%", loc=3, borderpad=1)
+    ins2 = inset_axes(ax, width="100%", height="100%",
+                      bbox_to_anchor=(0, 0, .35, .60),
+                      bbox_transform=ax.transAxes, loc=3, borderpad=1)
+    fig.canvas.draw()
+    assert_array_equal(ins1.get_position().extents,
+                       ins2.get_position().extents)
+
+    with pytest.raises(ValueError):
+        ins = inset_axes(ax, width="40%", height="30%",
+                         bbox_to_anchor=(0.4, 0.5))
+
+    with pytest.warns(UserWarning):
+        ins = inset_axes(ax, width="40%", height="30%",
+                         bbox_transform=ax.transAxes)
+
+
+@image_comparison(['fill_facecolor.png'], remove_text=True, style='mpl20')
+def test_fill_facecolor():
+    fig, ax = plt.subplots(1, 5)
+    fig.set_size_inches(5, 5)
+    for i in range(1, 4):
+        ax[i].yaxis.set_visible(False)
+    ax[4].yaxis.tick_right()
+    bbox = Bbox.from_extents(0, 0.4, 1, 0.6)
+
+    # fill with blue by setting 'fc' field
+    bbox1 = TransformedBbox(bbox, ax[0].transData)
+    bbox2 = TransformedBbox(bbox, ax[1].transData)
+    # set color to BboxConnectorPatch
+    p = BboxConnectorPatch(
+        bbox1, bbox2, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", fc="b")
+    p.set_clip_on(False)
+    ax[0].add_patch(p)
+    # set color to marked area
+    axins = zoomed_inset_axes(ax[0], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    plt.gca().axes.get_xaxis().set_ticks([])
+    plt.gca().axes.get_yaxis().set_ticks([])
+    mark_inset(ax[0], axins, loc1=2, loc2=4, fc="b", ec="0.5")
+
+    # fill with yellow by setting 'facecolor' field
+    bbox3 = TransformedBbox(bbox, ax[1].transData)
+    bbox4 = TransformedBbox(bbox, ax[2].transData)
+    # set color to BboxConnectorPatch
+    p = BboxConnectorPatch(
+        bbox3, bbox4, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", facecolor="y")
+    p.set_clip_on(False)
+    ax[1].add_patch(p)
+    # set color to marked area
+    axins = zoomed_inset_axes(ax[1], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    plt.gca().axes.get_xaxis().set_ticks([])
+    plt.gca().axes.get_yaxis().set_ticks([])
+    mark_inset(ax[1], axins, loc1=2, loc2=4, facecolor="y", ec="0.5")
+
+    # fill with green by setting 'color' field
+    bbox5 = TransformedBbox(bbox, ax[2].transData)
+    bbox6 = TransformedBbox(bbox, ax[3].transData)
+    # set color to BboxConnectorPatch
+    p = BboxConnectorPatch(
+        bbox5, bbox6, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", color="g")
+    p.set_clip_on(False)
+    ax[2].add_patch(p)
+    # set color to marked area
+    axins = zoomed_inset_axes(ax[2], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    plt.gca().axes.get_xaxis().set_ticks([])
+    plt.gca().axes.get_yaxis().set_ticks([])
+    mark_inset(ax[2], axins, loc1=2, loc2=4, color="g", ec="0.5")
+
+    # fill with green but color won't show if set fill to False
+    bbox7 = TransformedBbox(bbox, ax[3].transData)
+    bbox8 = TransformedBbox(bbox, ax[4].transData)
+    # BboxConnectorPatch won't show green
+    p = BboxConnectorPatch(
+        bbox7, bbox8, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", fc="g", fill=False)
+    p.set_clip_on(False)
+    ax[3].add_patch(p)
+    # marked area won't show green
+    axins = zoomed_inset_axes(ax[3], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    axins.get_xaxis().set_ticks([])
+    axins.get_yaxis().set_ticks([])
+    mark_inset(ax[3], axins, loc1=2, loc2=4, fc="g", ec="0.5", fill=False)
+
+
+@image_comparison(['zoomed_axes.png', 'inverted_zoomed_axes.png'])
+def test_zooming_with_inverted_axes():
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 2, 3])
+    ax.axis([1, 3, 1, 3])
+    inset_ax = zoomed_inset_axes(ax, zoom=2.5, loc='lower right')
+    inset_ax.axis([1.1, 1.4, 1.1, 1.4])
+
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 2, 3])
+    ax.axis([3, 1, 3, 1])
+    inset_ax = zoomed_inset_axes(ax, zoom=2.5, loc='lower right')
+    inset_ax.axis([1.4, 1.1, 1.4, 1.1])
+
+
+@image_comparison(['anchored_direction_arrows.png'],
+                  tol=0 if platform.machine() == 'x86_64' else 0.01)
+def test_anchored_direction_arrows():
+    fig, ax = plt.subplots()
+    ax.imshow(np.zeros((10, 10)), interpolation='nearest')
+
+    simple_arrow = AnchoredDirectionArrows(ax.transAxes, 'X', 'Y')
+    ax.add_artist(simple_arrow)
+
+
+@image_comparison(['anchored_direction_arrows_many_args.png'])
+def test_anchored_direction_arrows_many_args():
+    fig, ax = plt.subplots()
+    ax.imshow(np.ones((10, 10)))
+
+    direction_arrows = AnchoredDirectionArrows(
+            ax.transAxes, 'A', 'B', loc='upper right', color='red',
+            aspect_ratio=-0.5, pad=0.6, borderpad=2, frameon=True, alpha=0.7,
+            sep_x=-0.06, sep_y=-0.08, back_length=0.1, head_width=9,
+            head_length=10, tail_width=5)
+    ax.add_artist(direction_arrows)
+
+
+def test_axes_locatable_position():
+    fig, ax = plt.subplots()
+    divider = make_axes_locatable(ax)
+    cax = divider.append_axes('right', size='5%', pad='2%')
+    fig.canvas.draw()
+    assert np.isclose(cax.get_position(original=False).width,
+                      0.03621495327102808)
+
+
+@image_comparison(['image_grid.png'],
+                  remove_text=True, style='mpl20',
+                  savefig_kwarg={'bbox_inches': 'tight'})
+def test_image_grid():
+    # test that image grid works with bbox_inches=tight.
+    im = np.arange(100).reshape((10, 10))
+
+    fig = plt.figure(1, (4, 4))
+    grid = ImageGrid(fig, 111, nrows_ncols=(2, 2), axes_pad=0.1)
+
+    for i in range(4):
+        grid[i].imshow(im, interpolation='nearest')
+        grid[i].set_title('test {0}{0}'.format(i))
+
+
+def test_gettightbbox():
+    fig, ax = plt.subplots(figsize=(8, 6))
+
+    l, = ax.plot([1, 2, 3], [0, 1, 0])
+
+    ax_zoom = zoomed_inset_axes(ax, 4)
+    ax_zoom.plot([1, 2, 3], [0, 1, 0])
+
+    mark_inset(ax, ax_zoom, loc1=1, loc2=3, fc="none", ec='0.3')
+
+    remove_ticks_and_titles(fig)
+    bbox = fig.get_tightbbox(fig.canvas.get_renderer())
+    np.testing.assert_array_almost_equal(bbox.extents,
+                                         [-17.7, -13.9, 7.2, 5.4])
+
+
+@pytest.mark.parametrize("click_on", ["big", "small"])
+@pytest.mark.parametrize("big_on_axes,small_on_axes", [
+    ("gca", "gca"),
+    ("host", "host"),
+    ("host", "parasite"),
+    ("parasite", "host"),
+    ("parasite", "parasite")
+])
+def test_picking_callbacks_overlap(big_on_axes, small_on_axes, click_on):
+    """Test pick events on normal, host or parasite axes."""
+    # Two rectangles are drawn and "clicked on", a small one and a big one
+    # enclosing the small one. The axis on which they are drawn as well as the
+    # rectangle that is clicked on are varied.
+    # In each case we expect that both rectangles are picked if we click on the
+    # small one and only the big one is picked if we click on the big one.
+    # Also tests picking on normal axes ("gca") as a control.
+    big = plt.Rectangle((0.25, 0.25), 0.5, 0.5, picker=5)
+    small = plt.Rectangle((0.4, 0.4), 0.2, 0.2, facecolor="r", picker=5)
+    # Machinery for "receiving" events
+    received_events = []
+    def on_pick(event):
+        received_events.append(event)
+    plt.gcf().canvas.mpl_connect('pick_event', on_pick)
+    # Shortcut
+    rectangles_on_axes = (big_on_axes, small_on_axes)
+    # Axes setup
+    axes = {"gca": None, "host": None, "parasite": None}
+    if "gca" in rectangles_on_axes:
+        axes["gca"] = plt.gca()
+    if "host" in rectangles_on_axes or "parasite" in rectangles_on_axes:
+        axes["host"] = host_subplot(111)
+        axes["parasite"] = axes["host"].twin()
+    # Add rectangles to axes
+    axes[big_on_axes].add_patch(big)
+    axes[small_on_axes].add_patch(small)
+    # Simulate picking with click mouse event
+    if click_on == "big":
+        click_axes = axes[big_on_axes]
+        axes_coords = (0.3, 0.3)
+    else:
+        click_axes = axes[small_on_axes]
+        axes_coords = (0.5, 0.5)
+    # In reality mouse events never happen on parasite axes, only host axes
+    if click_axes is axes["parasite"]:
+        click_axes = axes["host"]
+    (x, y) = click_axes.transAxes.transform(axes_coords)
+    m = MouseEvent("button_press_event", click_axes.figure.canvas, x, y,
+                   button=1)
+    click_axes.pick(m)
+    # Checks
+    expected_n_events = 2 if click_on == "small" else 1
+    assert len(received_events) == expected_n_events
+    event_rects = [event.artist for event in received_events]
+    assert big in event_rects
+    if click_on == "small":
+        assert small in event_rects
+
+
+def test_hbox_divider():
+    arr1 = np.arange(20).reshape((4, 5))
+    arr2 = np.arange(20).reshape((5, 4))
+
+    fig, (ax1, ax2) = plt.subplots(1, 2)
+    ax1.imshow(arr1)
+    ax2.imshow(arr2)
+
+    pad = 0.5  # inches.
+    divider = HBoxDivider(
+        fig, 111,  # Position of combined axes.
+        horizontal=[Size.AxesX(ax1), Size.Fixed(pad), Size.AxesX(ax2)],
+        vertical=[Size.AxesY(ax1), Size.Scaled(1), Size.AxesY(ax2)])
+    ax1.set_axes_locator(divider.new_locator(0))
+    ax2.set_axes_locator(divider.new_locator(2))
+
+    fig.canvas.draw()
+    p1 = ax1.get_position()
+    p2 = ax2.get_position()
+    assert p1.height == p2.height
+    assert p2.width / p1.width == pytest.approx((4 / 5) ** 2)
+
+
+def test_axes_class_tuple():
+    fig = plt.figure()
+    axes_class = (mpl_toolkits.axes_grid1.mpl_axes.Axes, {})
+    gr = AxesGrid(fig, 111, nrows_ncols=(1, 1), axes_class=axes_class)

venv/Lib/site-packages/mpl_toolkits/tests/test_axisartist_angle_helper.py

@@ -0,0 +1,141 @@
+import re
+
+import numpy as np
+import pytest
+
+from mpl_toolkits.axisartist.angle_helper import (
+    FormatterDMS, FormatterHMS, select_step, select_step24, select_step360)
+
+
+_MS_RE = (
+    r'''\$  # Mathtext
+        (
+            # The sign sometimes appears on a 0 when a fraction is shown.
+            # Check later that there's only one.
+            (?P<degree_sign>-)?
+            (?P<degree>[0-9.]+)  # Degrees value
+            {degree}  # Degree symbol (to be replaced by format.)
+        )?
+        (
+            (?(degree)\\,)  # Separator if degrees are also visible.
+            (?P<minute_sign>-)?
+            (?P<minute>[0-9.]+)  # Minutes value
+            {minute}  # Minute symbol (to be replaced by format.)
+        )?
+        (
+            (?(minute)\\,)  # Separator if minutes are also visible.
+            (?P<second_sign>-)?
+            (?P<second>[0-9.]+)  # Seconds value
+            {second}  # Second symbol (to be replaced by format.)
+        )?
+        \$  # Mathtext
+    '''
+)
+DMS_RE = re.compile(_MS_RE.format(degree=re.escape(FormatterDMS.deg_mark),
+                                  minute=re.escape(FormatterDMS.min_mark),
+                                  second=re.escape(FormatterDMS.sec_mark)),
+                    re.VERBOSE)
+HMS_RE = re.compile(_MS_RE.format(degree=re.escape(FormatterHMS.deg_mark),
+                                  minute=re.escape(FormatterHMS.min_mark),
+                                  second=re.escape(FormatterHMS.sec_mark)),
+                    re.VERBOSE)
+
+
+def dms2float(degrees, minutes=0, seconds=0):
+    return degrees + minutes / 60.0 + seconds / 3600.0
+
+
+@pytest.mark.parametrize('args, kwargs, expected_levels, expected_factor', [
+    ((-180, 180, 10), {'hour': False}, np.arange(-180, 181, 30), 1.0),
+    ((-12, 12, 10), {'hour': True}, np.arange(-12, 13, 2), 1.0)
+])
+def test_select_step(args, kwargs, expected_levels, expected_factor):
+    levels, n, factor = select_step(*args, **kwargs)
+
+    assert n == len(levels)
+    np.testing.assert_array_equal(levels, expected_levels)
+    assert factor == expected_factor
+
+
+@pytest.mark.parametrize('args, kwargs, expected_levels, expected_factor', [
+    ((-180, 180, 10), {}, np.arange(-180, 181, 30), 1.0),
+    ((-12, 12, 10), {}, np.arange(-750, 751, 150), 60.0)
+])
+def test_select_step24(args, kwargs, expected_levels, expected_factor):
+    levels, n, factor = select_step24(*args, **kwargs)
+
+    assert n == len(levels)
+    np.testing.assert_array_equal(levels, expected_levels)
+    assert factor == expected_factor
+
+
+@pytest.mark.parametrize('args, kwargs, expected_levels, expected_factor', [
+    ((dms2float(20, 21.2), dms2float(21, 33.3), 5), {},
+     np.arange(1215, 1306, 15), 60.0),
+    ((dms2float(20.5, seconds=21.2), dms2float(20.5, seconds=33.3), 5), {},
+     np.arange(73820, 73835, 2), 3600.0),
+    ((dms2float(20, 21.2), dms2float(20, 53.3), 5), {},
+     np.arange(1220, 1256, 5), 60.0),
+    ((21.2, 33.3, 5), {},
+     np.arange(20, 35, 2), 1.0),
+    ((dms2float(20, 21.2), dms2float(21, 33.3), 5), {},
+     np.arange(1215, 1306, 15), 60.0),
+    ((dms2float(20.5, seconds=21.2), dms2float(20.5, seconds=33.3), 5), {},
+     np.arange(73820, 73835, 2), 3600.0),
+    ((dms2float(20.5, seconds=21.2), dms2float(20.5, seconds=21.4), 5), {},
+     np.arange(7382120, 7382141, 5), 360000.0),
+    # test threshold factor
+    ((dms2float(20.5, seconds=11.2), dms2float(20.5, seconds=53.3), 5),
+     {'threshold_factor': 60}, np.arange(12301, 12310), 600.0),
+    ((dms2float(20.5, seconds=11.2), dms2float(20.5, seconds=53.3), 5),
+     {'threshold_factor': 1}, np.arange(20502, 20517, 2), 1000.0),
+])
+def test_select_step360(args, kwargs, expected_levels, expected_factor):
+    levels, n, factor = select_step360(*args, **kwargs)
+
+    assert n == len(levels)
+    np.testing.assert_array_equal(levels, expected_levels)
+    assert factor == expected_factor
+
+
+@pytest.mark.parametrize('Formatter, regex',
+                         [(FormatterDMS, DMS_RE),
+                          (FormatterHMS, HMS_RE)],
+                         ids=['Degree/Minute/Second', 'Hour/Minute/Second'])
+@pytest.mark.parametrize('direction, factor, values', [
+    ("left", 60, [0, -30, -60]),
+    ("left", 600, [12301, 12302, 12303]),
+    ("left", 3600, [0, -30, -60]),
+    ("left", 36000, [738210, 738215, 738220]),
+    ("left", 360000, [7382120, 7382125, 7382130]),
+    ("left", 1., [45, 46, 47]),
+    ("left", 10., [452, 453, 454]),
+])
+def test_formatters(Formatter, regex, direction, factor, values):
+    fmt = Formatter()
+    result = fmt(direction, factor, values)
+
+    prev_degree = prev_minute = prev_second = None
+    for tick, value in zip(result, values):
+        m = regex.match(tick)
+        assert m is not None, f'{tick!r} is not an expected tick format.'
+
+        sign = sum(m.group(sign + '_sign') is not None
+                   for sign in ('degree', 'minute', 'second'))
+        assert sign <= 1, f'Only one element of tick {tick!r} may have a sign.'
+        sign = 1 if sign == 0 else -1
+
+        degree = float(m.group('degree') or prev_degree or 0)
+        minute = float(m.group('minute') or prev_minute or 0)
+        second = float(m.group('second') or prev_second or 0)
+        if Formatter == FormatterHMS:
+            # 360 degrees as plot range -> 24 hours as labelled range
+            expected_value = pytest.approx((value // 15) / factor)
+        else:
+            expected_value = pytest.approx(value / factor)
+        assert sign * dms2float(degree, minute, second) == expected_value, \
+            f'{tick!r} does not match expected tick value.'
+
+        prev_degree = degree
+        prev_minute = minute
+        prev_second = second

venv/Lib/site-packages/mpl_toolkits/tests/test_axisartist_axis_artist.py

@@ -0,0 +1,99 @@
+import matplotlib.pyplot as plt
+from matplotlib.testing.decorators import image_comparison
+
+from mpl_toolkits.axisartist import AxisArtistHelperRectlinear
+from mpl_toolkits.axisartist.axis_artist import (AxisArtist, AxisLabel,
+                                                 LabelBase, Ticks, TickLabels)
+
+
+@image_comparison(['axis_artist_ticks.png'], style='default')
+def test_ticks():
+    fig, ax = plt.subplots()
+
+    ax.xaxis.set_visible(False)
+    ax.yaxis.set_visible(False)
+
+    locs_angles = [((i / 10, 0.0), i * 30) for i in range(-1, 12)]
+
+    ticks_in = Ticks(ticksize=10, axis=ax.xaxis)
+    ticks_in.set_locs_angles(locs_angles)
+    ax.add_artist(ticks_in)
+
+    ticks_out = Ticks(ticksize=10, tick_out=True, color='C3', axis=ax.xaxis)
+    ticks_out.set_locs_angles(locs_angles)
+    ax.add_artist(ticks_out)
+
+
+@image_comparison(['axis_artist_labelbase.png'], style='default')
+def test_labelbase():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig, ax = plt.subplots()
+
+    ax.plot([0.5], [0.5], "o")
+
+    label = LabelBase(0.5, 0.5, "Test")
+    label._set_ref_angle(-90)
+    label._set_offset_radius(offset_radius=50)
+    label.set_rotation(-90)
+    label.set(ha="center", va="top")
+    ax.add_artist(label)
+
+
+@image_comparison(['axis_artist_ticklabels.png'], style='default')
+def test_ticklabels():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig, ax = plt.subplots()
+
+    ax.xaxis.set_visible(False)
+    ax.yaxis.set_visible(False)
+
+    ax.plot([0.2, 0.4], [0.5, 0.5], "o")
+
+    ticks = Ticks(ticksize=10, axis=ax.xaxis)
+    ax.add_artist(ticks)
+    locs_angles_labels = [((0.2, 0.5), -90, "0.2"),
+                          ((0.4, 0.5), -120, "0.4")]
+    tick_locs_angles = [(xy, a + 180) for xy, a, l in locs_angles_labels]
+    ticks.set_locs_angles(tick_locs_angles)
+
+    ticklabels = TickLabels(axis_direction="left")
+    ticklabels._locs_angles_labels = locs_angles_labels
+    ticklabels.set_pad(10)
+    ax.add_artist(ticklabels)
+
+    ax.plot([0.5], [0.5], "s")
+    axislabel = AxisLabel(0.5, 0.5, "Test")
+    axislabel._set_offset_radius(20)
+    axislabel._set_ref_angle(0)
+    axislabel.set_axis_direction("bottom")
+    ax.add_artist(axislabel)
+
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+
+
+@image_comparison(['axis_artist.png'], style='default')
+def test_axis_artist():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig, ax = plt.subplots()
+
+    ax.xaxis.set_visible(False)
+    ax.yaxis.set_visible(False)
+
+    for loc in ('left', 'right', 'bottom'):
+        _helper = AxisArtistHelperRectlinear.Fixed(ax, loc=loc)
+        axisline = AxisArtist(ax, _helper, offset=None, axis_direction=loc)
+        ax.add_artist(axisline)
+
+    # Settings for bottom AxisArtist.
+    axisline.set_label("TTT")
+    axisline.major_ticks.set_tick_out(False)
+    axisline.label.set_pad(5)
+
+    ax.set_ylabel("Test")

venv/Lib/site-packages/mpl_toolkits/tests/test_axisartist_axislines.py

@@ -0,0 +1,93 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.testing.decorators import image_comparison
+from matplotlib.transforms import IdentityTransform
+
+from mpl_toolkits.axisartist.axislines import SubplotZero, Subplot
+from mpl_toolkits.axisartist import SubplotHost, ParasiteAxesAuxTrans
+
+from mpl_toolkits.axisartist import Axes
+
+
+@image_comparison(['SubplotZero.png'], style='default')
+def test_SubplotZero():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig = plt.figure()
+
+    ax = SubplotZero(fig, 1, 1, 1)
+    fig.add_subplot(ax)
+
+    ax.axis["xzero"].set_visible(True)
+    ax.axis["xzero"].label.set_text("Axis Zero")
+
+    for n in ["top", "right"]:
+        ax.axis[n].set_visible(False)
+
+    xx = np.arange(0, 2 * np.pi, 0.01)
+    ax.plot(xx, np.sin(xx))
+    ax.set_ylabel("Test")
+
+
+@image_comparison(['Subplot.png'], style='default')
+def test_Subplot():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig = plt.figure()
+
+    ax = Subplot(fig, 1, 1, 1)
+    fig.add_subplot(ax)
+
+    xx = np.arange(0, 2 * np.pi, 0.01)
+    ax.plot(xx, np.sin(xx))
+    ax.set_ylabel("Test")
+
+    ax.axis["top"].major_ticks.set_tick_out(True)
+    ax.axis["bottom"].major_ticks.set_tick_out(True)
+
+    ax.axis["bottom"].set_label("Tk0")
+
+
+def test_Axes():
+    fig = plt.figure()
+    ax = Axes(fig, [0.15, 0.1, 0.65, 0.8])
+    fig.add_axes(ax)
+    ax.plot([1, 2, 3], [0, 1, 2])
+    ax.set_xscale('log')
+    fig.canvas.draw()
+
+
+@image_comparison(['ParasiteAxesAuxTrans_meshplot.png'],
+                  remove_text=True, style='default', tol=0.075)
+def test_ParasiteAxesAuxTrans():
+
+    data = np.ones((6, 6))
+    data[2, 2] = 2
+    data[0, :] = 0
+    data[-2, :] = 0
+    data[:, 0] = 0
+    data[:, -2] = 0
+    x = np.arange(6)
+    y = np.arange(6)
+    xx, yy = np.meshgrid(x, y)
+
+    funcnames = ['pcolor', 'pcolormesh', 'contourf']
+
+    fig = plt.figure()
+    for i, name in enumerate(funcnames):
+
+        ax1 = SubplotHost(fig, 1, 3, i+1)
+        fig.add_subplot(ax1)
+
+        ax2 = ParasiteAxesAuxTrans(ax1, IdentityTransform())
+        ax1.parasites.append(ax2)
+        if name.startswith('pcolor'):
+            getattr(ax2, name)(xx, yy, data[:-1, :-1])
+        else:
+            getattr(ax2, name)(xx, yy, data)
+        ax1.set_xlim((0, 5))
+        ax1.set_ylim((0, 5))
+
+    ax2.contour(xx, yy, data, colors='k')

venv/Lib/site-packages/mpl_toolkits/tests/test_axisartist_clip_path.py

@@ -0,0 +1,32 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.testing.decorators import image_comparison
+from matplotlib.transforms import Bbox
+
+from mpl_toolkits.axisartist.clip_path import clip_line_to_rect
+
+
+@image_comparison(['clip_path.png'], style='default')
+def test_clip_path():
+    x = np.array([-3, -2, -1, 0., 1, 2, 3, 2, 1, 0, -1, -2, -3, 5])
+    y = np.arange(len(x))
+
+    fig, ax = plt.subplots()
+    ax.plot(x, y, lw=1)
+
+    bbox = Bbox.from_extents(-2, 3, 2, 12.5)
+    rect = plt.Rectangle(bbox.p0, bbox.width, bbox.height,
+                         facecolor='none', edgecolor='k', ls='--')
+    ax.add_patch(rect)
+
+    clipped_lines, ticks = clip_line_to_rect(x, y, bbox)
+    for lx, ly in clipped_lines:
+        ax.plot(lx, ly, lw=1, color='C1')
+        for px, py in zip(lx, ly):
+            assert bbox.contains(px, py)
+
+    ccc = iter(['C3o', 'C2x', 'C3o', 'C2x'])
+    for ttt in ticks:
+        cc = next(ccc)
+        for (xx, yy), aa in ttt:
+            ax.plot([xx], [yy], cc)

venv/Lib/site-packages/mpl_toolkits/tests/test_axisartist_floating_axes.py

@@ -0,0 +1,120 @@
+import numpy as np
+
+import matplotlib.pyplot as plt
+import matplotlib.projections as mprojections
+import matplotlib.transforms as mtransforms
+from matplotlib.testing.decorators import image_comparison
+from mpl_toolkits.axisartist.axislines import Subplot
+from mpl_toolkits.axisartist.floating_axes import (
+    FloatingSubplot,
+    GridHelperCurveLinear)
+from mpl_toolkits.axisartist.grid_finder import FixedLocator
+from mpl_toolkits.axisartist import angle_helper
+
+
+def test_subplot():
+    fig = plt.figure(figsize=(5, 5))
+    ax = Subplot(fig, 111)
+    fig.add_subplot(ax)
+
+
+@image_comparison(['curvelinear3.png'], style='default', tol=0.01)
+def test_curvelinear3():
+    fig = plt.figure(figsize=(5, 5))
+
+    tr = (mtransforms.Affine2D().scale(np.pi / 180, 1) +
+          mprojections.PolarAxes.PolarTransform())
+
+    grid_locator1 = angle_helper.LocatorDMS(15)
+    tick_formatter1 = angle_helper.FormatterDMS()
+
+    grid_locator2 = FixedLocator([2, 4, 6, 8, 10])
+
+    grid_helper = GridHelperCurveLinear(tr,
+                                        extremes=(0, 360, 10, 3),
+                                        grid_locator1=grid_locator1,
+                                        grid_locator2=grid_locator2,
+                                        tick_formatter1=tick_formatter1,
+                                        tick_formatter2=None)
+
+    ax1 = FloatingSubplot(fig, 111, grid_helper=grid_helper)
+    fig.add_subplot(ax1)
+
+    r_scale = 10
+    tr2 = mtransforms.Affine2D().scale(1, 1 / r_scale) + tr
+    grid_locator2 = FixedLocator([30, 60, 90])
+    grid_helper2 = GridHelperCurveLinear(tr2,
+                                         extremes=(0, 360,
+                                                   10 * r_scale, 3 * r_scale),
+                                         grid_locator2=grid_locator2)
+
+    ax1.axis["right"] = axis = grid_helper2.new_fixed_axis("right", axes=ax1)
+
+    ax1.axis["left"].label.set_text("Test 1")
+    ax1.axis["right"].label.set_text("Test 2")
+
+    for an in ["left", "right"]:
+        ax1.axis[an].set_visible(False)
+
+    axis = grid_helper.new_floating_axis(1, 7, axes=ax1,
+                                         axis_direction="bottom")
+    ax1.axis["z"] = axis
+    axis.toggle(all=True, label=True)
+    axis.label.set_text("z = ?")
+    axis.label.set_visible(True)
+    axis.line.set_color("0.5")
+
+    ax2 = ax1.get_aux_axes(tr)
+
+    xx, yy = [67, 90, 75, 30], [2, 5, 8, 4]
+    ax2.scatter(xx, yy)
+    l, = ax2.plot(xx, yy, "k-")
+    l.set_clip_path(ax1.patch)
+
+
+@image_comparison(['curvelinear4.png'], style='default', tol=0.015)
+def test_curvelinear4():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig = plt.figure(figsize=(5, 5))
+
+    tr = (mtransforms.Affine2D().scale(np.pi / 180, 1) +
+          mprojections.PolarAxes.PolarTransform())
+
+    grid_locator1 = angle_helper.LocatorDMS(5)
+    tick_formatter1 = angle_helper.FormatterDMS()
+
+    grid_locator2 = FixedLocator([2, 4, 6, 8, 10])
+
+    grid_helper = GridHelperCurveLinear(tr,
+                                        extremes=(120, 30, 10, 0),
+                                        grid_locator1=grid_locator1,
+                                        grid_locator2=grid_locator2,
+                                        tick_formatter1=tick_formatter1,
+                                        tick_formatter2=None)
+
+    ax1 = FloatingSubplot(fig, 111, grid_helper=grid_helper)
+    fig.add_subplot(ax1)
+
+    ax1.axis["left"].label.set_text("Test 1")
+    ax1.axis["right"].label.set_text("Test 2")
+
+    for an in ["top"]:
+        ax1.axis[an].set_visible(False)
+
+    axis = grid_helper.new_floating_axis(1, 70, axes=ax1,
+                                         axis_direction="bottom")
+    ax1.axis["z"] = axis
+    axis.toggle(all=True, label=True)
+    axis.label.set_axis_direction("top")
+    axis.label.set_text("z = ?")
+    axis.label.set_visible(True)
+    axis.line.set_color("0.5")
+
+    ax2 = ax1.get_aux_axes(tr)
+
+    xx, yy = [67, 90, 75, 30], [2, 5, 8, 4]
+    ax2.scatter(xx, yy)
+    l, = ax2.plot(xx, yy, "k-")
+    l.set_clip_path(ax1.patch)

venv/Lib/site-packages/mpl_toolkits/tests/test_axisartist_grid_finder.py

@@ -0,0 +1,13 @@
+from mpl_toolkits.axisartist.grid_finder import (
+    FormatterPrettyPrint,
+    MaxNLocator)
+
+
+def test_pretty_print_format():
+    locator = MaxNLocator()
+    locs, nloc, factor = locator(0, 100)
+
+    fmt = FormatterPrettyPrint()
+
+    assert fmt("left", None, locs) == \
+        [r'$\mathdefault{%d}$' % (l, ) for l in locs]

venv/Lib/site-packages/mpl_toolkits/tests/test_axisartist_grid_helper_curvelinear.py

@@ -0,0 +1,213 @@
+import numpy as np
+import platform
+
+import matplotlib.pyplot as plt
+from matplotlib.path import Path
+from matplotlib.projections import PolarAxes
+from matplotlib.transforms import Affine2D, Transform
+from matplotlib.testing.decorators import image_comparison
+
+from mpl_toolkits.axes_grid1.parasite_axes import ParasiteAxesAuxTrans
+from mpl_toolkits.axisartist import SubplotHost
+from mpl_toolkits.axes_grid1.parasite_axes import host_subplot_class_factory
+from mpl_toolkits.axisartist import angle_helper
+from mpl_toolkits.axisartist.axislines import Axes
+from mpl_toolkits.axisartist.grid_helper_curvelinear import \
+    GridHelperCurveLinear
+
+
+@image_comparison(['custom_transform.png'], style='default',
+                  tol=0.03 if platform.machine() == 'x86_64' else 0.034)
+def test_custom_transform():
+    class MyTransform(Transform):
+        input_dims = output_dims = 2
+
+        def __init__(self, resolution):
+            """
+            Resolution is the number of steps to interpolate between each input
+            line segment to approximate its path in transformed space.
+            """
+            Transform.__init__(self)
+            self._resolution = resolution
+
+        def transform(self, ll):
+            x, y = ll.T
+            return np.column_stack([x, y - x])
+
+        transform_non_affine = transform
+
+        def transform_path(self, path):
+            ipath = path.interpolated(self._resolution)
+            return Path(self.transform(ipath.vertices), ipath.codes)
+
+        transform_path_non_affine = transform_path
+
+        def inverted(self):
+            return MyTransformInv(self._resolution)
+
+    class MyTransformInv(Transform):
+        input_dims = output_dims = 2
+
+        def __init__(self, resolution):
+            Transform.__init__(self)
+            self._resolution = resolution
+
+        def transform(self, ll):
+            x, y = ll.T
+            return np.column_stack([x, y + x])
+
+        def inverted(self):
+            return MyTransform(self._resolution)
+
+    fig = plt.figure()
+
+    SubplotHost = host_subplot_class_factory(Axes)
+
+    tr = MyTransform(1)
+    grid_helper = GridHelperCurveLinear(tr)
+    ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
+    fig.add_subplot(ax1)
+
+    ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
+    ax1.parasites.append(ax2)
+    ax2.plot([3, 6], [5.0, 10.])
+
+    ax1.set_aspect(1.)
+    ax1.set_xlim(0, 10)
+    ax1.set_ylim(0, 10)
+
+    ax1.grid(True)
+
+
+@image_comparison(['polar_box.png'], style='default',
+                  tol={'aarch64': 0.04}.get(platform.machine(), 0.03))
+def test_polar_box():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig = plt.figure(figsize=(5, 5))
+
+    # PolarAxes.PolarTransform takes radian. However, we want our coordinate
+    # system in degree
+    tr = Affine2D().scale(np.pi / 180., 1.) + PolarAxes.PolarTransform()
+
+    # polar projection, which involves cycle, and also has limits in
+    # its coordinates, needs a special method to find the extremes
+    # (min, max of the coordinate within the view).
+    extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,
+                                                     lon_cycle=360,
+                                                     lat_cycle=None,
+                                                     lon_minmax=None,
+                                                     lat_minmax=(0, np.inf))
+
+    grid_locator1 = angle_helper.LocatorDMS(12)
+    tick_formatter1 = angle_helper.FormatterDMS()
+
+    grid_helper = GridHelperCurveLinear(tr,
+                                        extreme_finder=extreme_finder,
+                                        grid_locator1=grid_locator1,
+                                        tick_formatter1=tick_formatter1)
+
+    ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
+
+    ax1.axis["right"].major_ticklabels.set_visible(True)
+    ax1.axis["top"].major_ticklabels.set_visible(True)
+
+    # let right axis shows ticklabels for 1st coordinate (angle)
+    ax1.axis["right"].get_helper().nth_coord_ticks = 0
+    # let bottom axis shows ticklabels for 2nd coordinate (radius)
+    ax1.axis["bottom"].get_helper().nth_coord_ticks = 1
+
+    fig.add_subplot(ax1)
+
+    ax1.axis["lat"] = axis = grid_helper.new_floating_axis(0, 45, axes=ax1)
+    axis.label.set_text("Test")
+    axis.label.set_visible(True)
+    axis.get_helper()._extremes = 2, 12
+
+    ax1.axis["lon"] = axis = grid_helper.new_floating_axis(1, 6, axes=ax1)
+    axis.label.set_text("Test 2")
+    axis.get_helper()._extremes = -180, 90
+
+    # A parasite axes with given transform
+    ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
+    assert ax2.transData == tr + ax1.transData
+    # Anything you draw in ax2 will match the ticks and grids of ax1.
+    ax1.parasites.append(ax2)
+    ax2.plot(np.linspace(0, 30, 50), np.linspace(10, 10, 50))
+
+    ax1.set_aspect(1.)
+    ax1.set_xlim(-5, 12)
+    ax1.set_ylim(-5, 10)
+
+    ax1.grid(True)
+
+
+@image_comparison(['axis_direction.png'], style='default', tol=0.03)
+def test_axis_direction():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig = plt.figure(figsize=(5, 5))
+
+    # PolarAxes.PolarTransform takes radian. However, we want our coordinate
+    # system in degree
+    tr = Affine2D().scale(np.pi / 180., 1.) + PolarAxes.PolarTransform()
+
+    # polar projection, which involves cycle, and also has limits in
+    # its coordinates, needs a special method to find the extremes
+    # (min, max of the coordinate within the view).
+
+    # 20, 20 : number of sampling points along x, y direction
+    extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,
+                                                     lon_cycle=360,
+                                                     lat_cycle=None,
+                                                     lon_minmax=None,
+                                                     lat_minmax=(0, np.inf),
+                                                     )
+
+    grid_locator1 = angle_helper.LocatorDMS(12)
+    tick_formatter1 = angle_helper.FormatterDMS()
+
+    grid_helper = GridHelperCurveLinear(tr,
+                                        extreme_finder=extreme_finder,
+                                        grid_locator1=grid_locator1,
+                                        tick_formatter1=tick_formatter1)
+
+    ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
+
+    for axis in ax1.axis.values():
+        axis.set_visible(False)
+
+    fig.add_subplot(ax1)
+
+    ax1.axis["lat1"] = axis = grid_helper.new_floating_axis(
+        0, 130,
+        axes=ax1, axis_direction="left")
+    axis.label.set_text("Test")
+    axis.label.set_visible(True)
+    axis.get_helper()._extremes = 0.001, 10
+
+    ax1.axis["lat2"] = axis = grid_helper.new_floating_axis(
+        0, 50,
+        axes=ax1, axis_direction="right")
+    axis.label.set_text("Test")
+    axis.label.set_visible(True)
+    axis.get_helper()._extremes = 0.001, 10
+
+    ax1.axis["lon"] = axis = grid_helper.new_floating_axis(
+        1, 10,
+        axes=ax1, axis_direction="bottom")
+    axis.label.set_text("Test 2")
+    axis.get_helper()._extremes = 50, 130
+    axis.major_ticklabels.set_axis_direction("top")
+    axis.label.set_axis_direction("top")
+
+    grid_helper.grid_finder.grid_locator1.set_params(nbins=5)
+    grid_helper.grid_finder.grid_locator2.set_params(nbins=5)
+
+    ax1.set_aspect(1.)
+    ax1.set_xlim(-8, 8)
+    ax1.set_ylim(-4, 12)
+
+    ax1.grid(True)