ultraplot 0.99.3__py3-none-any.whl

ultraplot/tests/test_2dplots.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""
+Test 2D plotting overrides.
+"""
+import numpy as np
+import pytest
+import xarray as xr
+
+import ultraplot as pplt
+
+state = np.random.RandomState(51423)
+
+
+@pytest.mark.skip("not sure what this does")
+@pytest.mark.mpl_image_compare
+def test_colormap_vcenter():
+    """
+    Test colormap vcenter.
+    """
+    fig, axs = pplt.subplots(ncols=3)
+    data = 10 * state.rand(10, 10) - 3
+    axs[0].pcolor(data, vcenter=0)
+    axs[1].pcolor(data, vcenter=1)
+    axs[2].pcolor(data, vcenter=2)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_auto_diverging1():
+    """
+    Test that auto diverging works.
+    """
+    # Test with basic data
+    fig = pplt.figure()
+    # fig.format(collabels=('Auto sequential', 'Auto diverging'), suptitle='Default')
+    ax = fig.subplot(121)
+    ax.pcolor(state.rand(10, 10) * 5, colorbar="b")
+    ax = fig.subplot(122)
+    ax.pcolor(state.rand(10, 10) * 5 - 3.5, colorbar="b")
+    fig.format(toplabels=("Sequential", "Diverging"))
+    return fig
+
+
+@pytest.mark.skip("Not sure what this does")
+@pytest.mark.mpl_image_compare
+def test_autodiverging2():
+    # Test with explicit vcenter
+    fig, axs = pplt.subplots(ncols=3)
+    data = 5 * state.rand(10, 10)
+    axs[0].pcolor(data, vcenter=0, colorbar="b")  # otherwise should be disabled
+    axs[1].pcolor(data, vcenter=1.5, colorbar="b")
+    axs[2].pcolor(data, vcenter=4, colorbar="b", symmetric=True)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_autodiverging3():
+    # Test when cmap input disables auto diverging.
+    fig, axs = pplt.subplots(ncols=2, nrows=2, refwidth=2)
+    cmap = pplt.Colormap(
+        ("red7", "red3", "red1", "blue1", "blue3", "blue7"), listmode="discrete"
+    )  # noqa: E501
+    data1 = 10 * state.rand(10, 10)
+    data2 = data1 - 2
+    for i, cmap in enumerate(("RdBu_r", cmap)):
+        for j, data in enumerate((data1, data2)):
+            cmap = pplt.Colormap(pplt.Colormap(cmap))
+            axs[i, j].pcolormesh(data, cmap=cmap, colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_autodiverging4():
+    fig, axs = pplt.subplots(ncols=3)
+    data = state.rand(5, 5) * 10 - 5
+    for i, ax in enumerate(axs[:2]):
+        ax.pcolor(data, sequential=bool(i), colorbar="b")
+    axs[2].pcolor(data, diverging=False, colorbar="b")  # should have same effect
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_autodiverging5():
+    fig, axs = pplt.subplots(ncols=2)
+    data = state.rand(5, 5) * 10 + 2
+    for ax, norm in zip(axs, (None, "div")):
+        ax.pcolor(data, norm=norm, colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_colormap_mode():
+    """
+    Test auto extending, auto discrete. Should issue warnings.
+    """
+    fig, axs = pplt.subplots(ncols=2, nrows=2, share=False)
+    axs[0].pcolor(state.rand(5, 5) % 0.3, extend="both", cyclic=True, colorbar="b")
+    axs[1].pcolor(state.rand(5, 5), sequential=True, diverging=True, colorbar="b")
+    axs[2].pcolor(state.rand(5, 5), discrete=False, qualitative=True, colorbar="b")
+    pplt.rc["cmap.discrete"] = False  # should be ignored below
+    axs[3].contourf(state.rand(5, 5), colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_contour_labels():
+    """
+    Test contour labels. We use a separate `contour` object when adding labels to
+    filled contours or else weird stuff happens (see below). We could just modify
+    filled contour edges when not adding labels but that would be inconsistent with
+    behavior when labels are active.
+    """
+    data = state.rand(5, 5) * 10 - 5
+    fig, axs = pplt.subplots(ncols=2)
+    ax = axs[0]
+    ax.contourf(
+        data,
+        edgecolor="k",
+        linewidth=1.5,
+        labels=True,
+        labels_kw={"color": "k", "size": "large"},
+    )
+    ax = axs[1]
+    m = ax.contourf(data)
+    ax.clabel(m, colors="black", fontsize="large")  # looks fine without this
+    for o in m.collections:
+        o.set_linewidth(1.5)
+        o.set_edgecolor("k")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_contour_negative():
+    """
+    Ensure `cmap.monochrome` properly assigned.
+    """
+    fig = pplt.figure(share=False)
+    ax = fig.subplot(131)
+    data = state.rand(10, 10) * 10 - 5
+    ax.contour(data, color="k")
+    ax = fig.subplot(132)
+    ax.tricontour(*(state.rand(3, 20) * 10 - 5), color="k")
+    ax = fig.subplot(133)
+    ax.contour(data, cmap=["black"])  # fails but that's ok
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_contour_single():
+    """
+    Test whether single contour works.
+    """
+    da = xr.DataArray(
+        np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]), dims=["y", "x"]
+    )
+    fig, ax = pplt.subplots()
+    ax.contour(da, levels=[5.0], color="r")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_edge_fix():
+    """
+    Test edge fix applied to 1D plotting utilities.
+    """
+    # Test basic application
+    # TODO: This should make no difference for PNG plots?
+    pplt.rc.edgefix = 1
+    fig, axs = pplt.subplots(ncols=2, share=False)
+    axs.format(grid=False)
+    axs[0].bar(
+        state.rand(
+            10,
+        )
+        * 10
+        - 5,
+        width=1,
+        negpos=True,
+    )
+    axs[1].area(state.rand(5, 3), stack=True)
+
+    # Test whether ignored for transparent colorbars
+    data = state.rand(10, 10)
+    cmap = "magma"
+    fig, axs = pplt.subplots(nrows=3, ncols=2, refwidth=2.5, share=False)
+    for i, iaxs in enumerate((axs[:2], axs[2:4])):
+        if i == 0:
+            cmap = pplt.Colormap("magma", alpha=0.5)
+            alpha = None
+            iaxs.format(title="Colormap alpha")
+        else:
+            cmap = "magma"
+            alpha = 0.5
+            iaxs.format(title="Single alpha")
+        iaxs[0].contourf(data, cmap=cmap, colorbar="b", alpha=alpha)
+        iaxs[1].pcolormesh(data, cmap=cmap, colorbar="b", alpha=alpha)
+    axs[4].bar(data[:3, :3], alpha=0.5)
+    axs[5].area(data[:3, :3], alpha=0.5, stack=True)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_flow_functions():
+    """
+    These are seldom used and missing from documentation. Be careful
+    not to break anything basic.
+    """
+    fig, ax = pplt.subplots()
+    for _ in range(2):
+        ax.streamplot(state.rand(10, 10), 5 * state.rand(10, 10), label="label")
+
+    fig, axs = pplt.subplots(ncols=2)
+    ax = axs[0]
+    ax.quiver(
+        state.rand(10, 10), 5 * state.rand(10, 10), c=state.rand(10, 10), label="label"
+    )
+    ax = axs[1]
+    ax.quiver(state.rand(10), state.rand(10), label="single")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_gray_adjustment():
+    """
+    Test gray adjustments when creating segmented colormaps.
+    """
+    fig, ax = pplt.subplots()
+    data = state.rand(5, 5) * 10 - 5
+    cmap = pplt.Colormap(["blue", "grey3", "red"])
+    ax.pcolor(data, cmap=cmap, colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_ignore_message():
+    """
+    Test various ignored argument warnings.
+    """
+    warning = pplt.internals.UltraplotWarning
+    fig, axs = pplt.subplots(ncols=2, nrows=2)
+    with pytest.warns(warning):
+        axs[0].contour(state.rand(5, 5) * 10, levels=pplt.arange(10), symmetric=True)
+    with pytest.warns(warning):
+        axs[1].contourf(
+            state.rand(10, 10), levels=np.linspace(0, 1, 10), locator=5, locator_kw={}
+        )
+    with pytest.warns(warning):
+        axs[2].contourf(
+            state.rand(10, 10),
+            levels=pplt.arange(0, 1, 0.2),
+            vmin=0,
+            vmax=2,
+            locator=3,
+            colorbar="b",
+        )
+    with pytest.warns(warning):
+        axs[3].hexbin(
+            state.rand(1000),
+            state.rand(1000),
+            levels=pplt.arange(0, 20),
+            gridsize=10,
+            locator=2,
+            colorbar="b",
+            cmap="blues",
+        )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_levels_with_vmin_vmax():
+    """
+    Make sure `vmin` and `vmax` go into level generation algorithm.
+    """
+    # Sample data
+    state = np.random.RandomState(51423)
+    x = y = np.array([-10, -5, 0, 5, 10])
+    data = state.rand(y.size, x.size)
+
+    # Figure
+    fig = pplt.figure(refwidth=2.3, share=False)
+    axs = fig.subplots()
+    m = axs.pcolormesh(x, y, data, vmax=1.35123)
+    axs.colorbar([m], loc="r")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_level_restriction():
+    """
+    Test `negative`, `positive`, and `symmetric` with and without discrete.
+    """
+    fig, axs = pplt.subplots(ncols=3, nrows=2)
+    data = 20 * state.rand(10, 10) - 5
+    keys = ("negative", "positive", "symmetric")
+    for i, grp in enumerate((axs[:3], axs[3:])):
+        for j, ax in enumerate(grp):
+            kw = {keys[j]: True, "discrete": bool(1 - i)}
+            ax.pcolor(data, **kw, colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_qualitative_colormaps_1():
+    """
+    Test both `colors` and `cmap` input and ensure extend setting is used for
+    extreme only if unset.
+    """
+    fig, axs = pplt.subplots(ncols=2)
+    data = state.rand(5, 5)
+    colors = pplt.get_colors("set3")
+    for ax, extend in zip(axs, ("both", "neither")):
+        ax.pcolor(data, extend=extend, colors=colors, colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_qualitative_colormaps_2():
+    fig, axs = pplt.subplots(ncols=2)
+    data = state.rand(5, 5)
+    cmap = pplt.Colormap("set3")
+    cmap.set_under("black")  # does not overwrite
+    for ax, extend in zip(axs, ("both", "neither")):
+        ax.pcolor(data, extend=extend, cmap=cmap, colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_segmented_norm():
+    """
+    Test segmented norm with non-discrete levels.
+    """
+    fig, ax = pplt.subplots()
+    ax.pcolor(
+        state.rand(5, 5) * 10,
+        discrete=False,
+        norm="segmented",
+        norm_kw={"levels": [0, 2, 10]},
+        colorbar="b",
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_triangular_functions():
+    """
+    Test triangular functions. Here there is no remotely sensible way to infer
+    """
+    fig, ax = pplt.subplots()
+    N = 30
+    y = state.rand(N) * 20
+    x = state.rand(N) * 50
+    da = xr.DataArray(state.rand(N), dims=("x",), coords={"x": x, "y": ("x", y)})
+    ax.tricontour(da.x, da.y, da, labels=True)
+    return fig

ultraplot/tests/test_axes.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Test twin, inset, and panel axes.
+"""
+import numpy as np
+import pytest
+import ultraplot as pplt
+
+state = np.random.RandomState(51423)
+
+
+def test_axis_access():
+    # attempt to access the ax object 2d and linearly
+    fix, ax = pplt.subplots(ncols=2, nrows=2)
+    ax[0, 0]
+    ax[1, 0]
+    with pytest.raises(IndexError):
+        ax[0, 3]
+    ax[3]
+
+
+@pytest.mark.mpl_image_compare
+def test_inset_colors_1():
+    """
+    Test color application for zoom boxes.
+    """
+    fig, ax = pplt.subplots()
+    ax.format(xlim=(0, 100), ylim=(0, 100))
+    ix = ax.inset_axes(
+        (0.5, 0.5, 0.3, 0.3), zoom=True, zoom_kw={"color": "r", "fc": "r", "ec": "b"}
+    )  # zoom_kw={'alpha': 1})
+    # ix = ax.inset_axes((40, 40, 20, 20), zoom=True, transform='data')
+    ix.format(xlim=(10, 20), ylim=(10, 20), grid=False)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_inset_colors_2():
+    fig, ax = pplt.subplots()
+    ax.format(xlim=(0, 100), ylim=(0, 100))
+    ix = ax.inset_axes(
+        (0.3, 0.5, 0.5, 0.3),
+        zoom=True,
+        zoom_kw={"lw": 3, "ec": "red9", "a": 1, "c": pplt.set_alpha("red4", 0.5)},
+    )
+    ix.format(xlim=(10, 20), ylim=(10, 20))
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_inset_zoom_update():
+    """
+    Test automatic limit adjusment with successive changes. Without the extra
+    lines in `draw()` and `get_tight_bbox()` this fails.
+    """
+    fig, ax = pplt.subplots()
+    ax.format(xlim=(0, 100), ylim=(0, 100))
+    ix = ax.inset_axes((40, 40, 20, 20), zoom=True, transform="data")
+    ix.format(xlim=(10, 20), ylim=(10, 20), grid=False)
+    ix.format(xlim=(10, 20), ylim=(10, 30))
+    ax.format(ylim=(0, 300))
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_panels_with_sharing():
+    """
+    Previously the below text would hide the second y label.
+    """
+    fig, axs = pplt.subplots(ncols=2, share=False, refwidth=1.5)
+    axs.panel("left")
+    fig.format(ylabel="ylabel", xlabel="xlabel")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_panels_without_sharing_1():
+    """
+    What should happen if `share=False` but figure-wide sharing enabled?
+    Strange use case but behavior appears "correct."
+    """
+    fig, axs = pplt.subplots(ncols=2, share=True, refwidth=1.5, includepanels=False)
+    axs.panel("left", share=False)
+    fig.format(ylabel="ylabel", xlabel="xlabel")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_panels_without_sharing_2():
+    fig, axs = pplt.subplots(ncols=2, refwidth=1.5, includepanels=True)
+    for _ in range(3):
+        p = axs[0].panel("l", space=0)
+        p.format(xlabel="label")
+    fig.format(xlabel="xlabel")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_panels_suplabels_three_hor_panels():
+    """
+    Test label sharing for `includepanels=True`.
+    Test for 1 subplot with 3 left panels
+    Include here centers the x label to include the panels
+    The xlabel should be centered along the main plot with the included side panels
+    """
+    fig = pplt.figure()
+    ax = fig.subplots(refwidth=1.5, includepanels=True)
+    for _ in range(3):
+        ax[0].panel("l")
+    ax.format(xlabel="xlabel", ylabel="ylabel\nylabel\nylabel", suptitle="sup")
+    return fig
+
+
+def test_panels_suplabels_three_hor_panels_donotinlcude():
+    """
+    Test label sharing for `includepanels=True`.
+    Test for 1 subplot with 3 left panels
+    The xlabel should be centered on the main plot
+    """
+    fig = pplt.figure()
+    ax = fig.subplots(refwidth=1.5, includepanels=False)
+    for _ in range(3):
+        ax[0].panel("l")
+    ax.format(
+        xlabel="xlabel",
+        ylabel="ylabel\nylabel\nylabel",
+        suptitle="sup",
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_twin_axes_1():
+    """
+    Adjust twin axis positions. Should allow easily switching the location.
+    """
+    # Test basic twin creation and tick, spine, label location changes
+    fig = pplt.figure()
+    ax = fig.subplot()
+    ax.format(
+        ycolor="blue",
+        ylabel="orig",
+        ylabelcolor="blue9",
+        yspineloc="l",
+        labelweight="bold",
+        xlabel="xlabel",
+        xtickloc="t",
+        xlabelloc="b",
+    )
+    ax.alty(loc="r", color="r", labelcolor="red9", label="other", labelweight="bold")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_twin_axes_2():
+    # Simple example but doesn't quite work. Figure out how to specify left vs. right
+    # spines for 'offset' locations... maybe needs another keyword.
+    fig, ax = pplt.subplots()
+    ax.format(ymax=10, ylabel="Reference")
+    ax.alty(color="green", label="Green", max=8)
+    ax.alty(color="red", label="Red", max=15, loc=("axes", -0.2))
+    ax.alty(color="blue", label="Blue", max=5, loc=("axes", 1.2), ticklabeldir="out")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_twin_axes_3():
+    # A worked example from Riley Brady
+    # Uses auto-adjusting limits
+    fig, ax = pplt.subplots()
+    axs = [ax, ax.twinx(), ax.twinx()]
+    axs[-1].spines["right"].set_position(("axes", 1.2))
+    colors = ("Green", "Red", "Blue")
+    for ax, color in zip(axs, colors):
+        data = state.random(1) * state.random(10)
+        ax.plot(data, marker="o", linestyle="none", color=color)
+        ax.format(ylabel="%s Thing" % color, ycolor=color)
+    axs[0].format(xlabel="xlabel")
+    return fig