ultraplot 0.99.3__py3-none-any.whl

ultraplot/tests/test_geographic.py

@@ -0,0 +1,116 @@
+import ultraplot as plt, numpy as np
+import pytest
+
+
+@pytest.mark.mpl_image_compare
+def test_geographic_single_projection():
+    fig = plt.figure(refwidth=3)
+    axs = fig.subplots(nrows=2, proj="robin", proj_kw={"lon_0": 180})
+    # proj = pplt.Proj('robin', lon_0=180)
+    # axs = pplt.subplots(nrows=2, proj=proj)  # equivalent to above
+    axs.format(
+        suptitle="Figure with single projection",
+        land=True,
+        latlines=30,
+        lonlines=60,
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_geographic_multiple_projections():
+    fig = plt.figure()
+    # Add projections
+    gs = plt.GridSpec(ncols=2, nrows=3, hratios=(1, 1, 1.4))
+    for i, proj in enumerate(("cyl", "hammer", "npstere")):
+        ax1 = fig.subplot(gs[i, 0], proj=proj, basemap=True)  # basemap
+        ax2 = fig.subplot(gs[i, 1], proj=proj)  # cartopy
+
+    # Format projections
+    fig.format(
+        land=True,
+        suptitle="Figure with several projections",
+        toplabels=("Basemap projections", "Cartopy projections"),
+        toplabelweight="normal",
+        latlines=30,
+        lonlines=60,
+        lonlabels="b",
+        latlabels="r",  # or lonlabels=True, labels=True, etc.
+    )
+    fig.subplotgrid[-2:].format(
+        latlines=20, lonlines=30
+    )  # dense gridlines for polar plots
+    plt.rc.reset()
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_drawing_in_projection_without_globe():
+    # Fake data with unusual longitude seam location and without coverage over poles
+    offset = -40
+    lon = plt.arange(offset, 360 + offset - 1, 60)
+    lat = plt.arange(-60, 60 + 1, 30)
+    state = np.random.RandomState(51423)
+    data = state.rand(len(lat), len(lon))
+
+    globe = False
+    string = "with" if globe else "without"
+    gs = plt.GridSpec(nrows=2, ncols=2)
+    fig = plt.figure(refwidth=2.5)
+    for i, ss in enumerate(gs):
+        ax = fig.subplot(ss, proj="kav7", basemap=(i % 2))
+        cmap = ("sunset", "sunrise")[i % 2]
+        if i > 1:
+            ax.pcolor(lon, lat, data, cmap=cmap, globe=globe, extend="both")
+        else:
+            m = ax.contourf(lon, lat, data, cmap=cmap, globe=globe, extend="both")
+            fig.colorbar(m, loc="b", span=i + 1, label="values", extendsize="1.7em")
+    fig.format(
+        suptitle=f"Geophysical data {string} global coverage",
+        toplabels=("Cartopy example", "Basemap example"),
+        leftlabels=("Filled contours", "Grid boxes"),
+        toplabelweight="normal",
+        leftlabelweight="normal",
+        coast=True,
+        lonlines=90,
+        abc="A.",
+        abcloc="ul",
+        abcborder=False,
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_drawing_in_projection_with_globe():
+    # Fake data with unusual longitude seam location and without coverage over poles
+    offset = -40
+    lon = plt.arange(offset, 360 + offset - 1, 60)
+    lat = plt.arange(-60, 60 + 1, 30)
+    state = np.random.RandomState(51423)
+    data = state.rand(len(lat), len(lon))
+
+    globe = True
+    string = "with" if globe else "without"
+    gs = plt.GridSpec(nrows=2, ncols=2)
+    fig = plt.figure(refwidth=2.5)
+    for i, ss in enumerate(gs):
+        ax = fig.subplot(ss, proj="kav7", basemap=(i % 2))
+        cmap = ("sunset", "sunrise")[i % 2]
+        if i > 1:
+            ax.pcolor(lon, lat, data, cmap=cmap, globe=globe, extend="both")
+        else:
+            m = ax.contourf(lon, lat, data, cmap=cmap, globe=globe, extend="both")
+            fig.colorbar(m, loc="b", span=i + 1, label="values", extendsize="1.7em")
+    fig.format(
+        suptitle=f"Geophysical data {string} global coverage",
+        toplabels=("Cartopy example", "Basemap example"),
+        leftlabels=("Filled contours", "Grid boxes"),
+        toplabelweight="normal",
+        leftlabelweight="normal",
+        coast=True,
+        lonlines=90,
+        abc="A.",
+        abcloc="ul",
+        abcborder=False,
+    )
+    return fig

ultraplot/tests/test_imshow.py

@@ -0,0 +1,110 @@
+import pytest
+
+import ultraplot as plt, numpy as np
+from matplotlib.testing import setup
+
+
+@pytest.fixture()
+def setup_mpl():
+    setup()
+    plt.clf()
+
+
+@pytest.mark.mpl_image_compare
+def test_standardized_input():
+    # Sample data
+    state = np.random.RandomState(51423)
+    x = y = np.array([-10, -5, 0, 5, 10])
+    xedges = plt.edges(x)
+    yedges = plt.edges(y)
+    data = state.rand(y.size, x.size)  # "center" coordinates
+    lim = (np.min(xedges), np.max(xedges))
+
+    with plt.rc.context({"cmap": "Grays", "cmap.levels": 21}):
+        # Figure
+        fig = plt.figure(refwidth=2.3, share=False)
+        axs = fig.subplots(ncols=2, nrows=2)
+        axs.format(
+            xlabel="xlabel",
+            ylabel="ylabel",
+            xlim=lim,
+            ylim=lim,
+            xlocator=5,
+            ylocator=5,
+            suptitle="Standardized input demonstration",
+            toplabels=("Coordinate centers", "Coordinate edges"),
+        )
+
+        # Plot using both centers and edges as coordinates
+        axs[0].pcolormesh(x, y, data)
+        axs[1].pcolormesh(xedges, yedges, data)
+        axs[2].contourf(x, y, data)
+        axs[3].contourf(xedges, yedges, data)
+    fig.show()
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_inbounds_data():
+    # Sample data
+    cmap = "turku_r"
+    state = np.random.RandomState(51423)
+    N = 80
+    x = y = np.arange(N + 1)
+    data = 10 + (state.normal(0, 3, size=(N, N))).cumsum(axis=0).cumsum(axis=1)
+    xlim = ylim = (0, 25)
+
+    # Plot the data
+    fig, axs = plt.subplots(
+        [[0, 1, 1, 0], [2, 2, 3, 3]],
+        wratios=(1.3, 1, 1, 1.3),
+        span=False,
+        refwidth=2.2,
+    )
+    axs[0].fill_between(
+        xlim,
+        *ylim,
+        zorder=3,
+        edgecolor="red",
+        facecolor=plt.set_alpha("red", 0.2),
+    )
+    for i, ax in enumerate(axs):
+        inbounds = i == 1
+        title = f"Restricted lims inbounds={inbounds}"
+        title += " (default)" if inbounds else ""
+        ax.format(
+            xlim=(None if i == 0 else xlim),
+            ylim=(None if i == 0 else ylim),
+            title=("Default axis limits" if i == 0 else title),
+        )
+        ax.pcolor(x, y, data, cmap=cmap, inbounds=inbounds)
+    fig.format(
+        xlabel="xlabel",
+        ylabel="ylabel",
+        suptitle="Default vmin/vmax restricted to in-bounds data",
+    )
+    fig.show()
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_colorbar():
+    # Sample data
+    state = np.random.RandomState(51423)
+    data = 10 + state.normal(0, 1, size=(33, 33)).cumsum(axis=0).cumsum(axis=1)
+
+    # Figure
+    fig, axs = plt.subplots([[1, 1, 2, 2], [0, 3, 3, 0]], ref=3, refwidth=2.3)
+    axs.format(yformatter="none", suptitle="Discrete vs. smooth colormap levels")
+
+    # Pcolor
+    axs[0].pcolor(data, cmap="viridis", colorbar="l")
+    axs[0].set_title("Pcolor plot\ndiscrete=True (default)")
+    axs[1].pcolor(data, discrete=False, cmap="viridis", colorbar="r")
+    axs[1].set_title("Pcolor plot\ndiscrete=False")
+
+    # Imshow
+    m = axs[2].imshow(data, cmap="oslo", colorbar="b")
+    axs[2].format(title="Imshow plot\ndiscrete=False (default)", yformatter="auto")
+    fig.show()
+    return fig

ultraplot/tests/test_inset.py

@@ -0,0 +1,28 @@
+import ultraplot as pplt, numpy as np, pytest
+
+
+@pytest.mark.mpl_image_compare
+def test_inset_basic():
+    # Demonstrate that complex arrangements preserve
+    # spacing, aspect ratios, and axis sharing
+    gs = pplt.GridSpec(nrows=2, ncols=2)
+    fig = pplt.figure(refwidth=1.5, share=False)
+    for ss, side in zip(gs, "tlbr"):
+        ax = fig.add_subplot(ss)
+        px = ax.panel_axes(side, width="3em")
+    fig.format(
+        xlim=(0, 1),
+        ylim=(0, 1),
+        xlabel="xlabel",
+        ylabel="ylabel",
+        xticks=0.2,
+        yticks=0.2,
+        title="Title",
+        suptitle="Complex arrangement of panels",
+        toplabels=("Column 1", "Column 2"),
+        abc=True,
+        abcloc="ul",
+        titleloc="uc",
+        titleabove=False,
+    )
+    return fig

ultraplot/tests/test_integration.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Test xarray, pandas, pint, seaborn integration.
+"""
+import numpy as np, pandas as pd, seaborn as sns
+import xarray as xr
+import ultraplot as pplt, pytest
+import pint
+
+state = np.random.RandomState(51423)
+
+
+@pytest.mark.mpl_image_compare
+def test_pint_quantities():
+    """
+    Ensure auto-formatting and column iteration both work.
+    """
+    pplt.rc.unitformat = "~H"
+    ureg = pint.UnitRegistry()
+    fig, ax = pplt.subplots()
+    ax.plot(
+        np.arange(10),
+        state.rand(10) * ureg.km,
+        "C0",
+        np.arange(10),
+        state.rand(10) * ureg.m * 1e2,
+        "C1",
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_data_keyword():
+    """
+    Make sure `data` keywords work properly.
+    """
+    N = 10
+    M = 20
+    ds = xr.Dataset(
+        {"z": (("x", "y"), state.rand(N, M))},
+        coords={
+            "x": ("x", np.arange(N) * 10, {"long_name": "longitude"}),
+            "y": ("y", np.arange(M) * 5, {"long_name": "latitude"}),
+        },
+    )
+    fig, ax = pplt.subplots()
+    # ax.pcolor('z', data=ds, order='F')
+    ax.pcolor(z="z", data=ds, transpose=True)
+    ax.format(xformatter="deglat", yformatter="deglon")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_keep_guide_labels():
+    """
+    Preserve metadata when passing mappables and handles to colorbar and
+    legend subsequently.
+    """
+    fig, ax = pplt.subplots()
+    df = pd.DataFrame(state.rand(5, 5))
+    df.name = "variable"
+    m = ax.pcolor(df)
+    ax.colorbar(m)
+
+    fig, ax = pplt.subplots()
+    for k in ("foo", "bar", "baz"):
+        s = pd.Series(state.rand(5), index=list("abcde"), name=k)
+        ax.plot(
+            s,
+            legend="ul",
+            legend_kw={
+                "lw": 5,
+                "ew": 2,
+                "ec": "r",
+                "fc": "w",
+                "handle_kw": {"marker": "d"},
+            },
+        )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_seaborn_swarmplot():
+    """
+    Test seaborn swarm plots.
+    """
+    tips = sns.load_dataset("tips")
+    fig = pplt.figure(refwidth=3)
+    ax = fig.subplot()
+    sns.swarmplot(ax=ax, x="day", y="total_bill", data=tips, palette="cubehelix")
+    # fig, ax = pplt.subplots()
+    # sns.swarmplot(y=state.normal(size=100), ax=ax)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_seaborn_hist():
+    """
+    Test seaborn histograms.
+    """
+    fig, axs = pplt.subplots(ncols=2, nrows=2)
+    sns.histplot(state.normal(size=100), ax=axs[0])
+    sns.kdeplot(x=state.rand(100), y=state.rand(100), ax=axs[1])
+    penguins = sns.load_dataset("penguins")
+    sns.histplot(
+        data=penguins, x="flipper_length_mm", hue="species", multiple="stack", ax=axs[2]
+    )
+    sns.kdeplot(
+        data=penguins, x="flipper_length_mm", hue="species", multiple="stack", ax=axs[3]
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_seaborn_relational():
+    """
+    Test scatter plots. Disabling seaborn detection creates mismatch between marker
+    sizes and legend.
+    """
+    fig = pplt.figure()
+    ax = fig.subplot()
+    sns.set_theme(style="white")
+    # Load the example mpg dataset
+    mpg = sns.load_dataset("mpg")
+    # Plot miles per gallon against horsepower with other semantics
+    sns.scatterplot(
+        x="horsepower",
+        y="mpg",
+        hue="origin",
+        size="weight",
+        sizes=(40, 400),
+        alpha=0.5,
+        palette="muted",
+        # legend='bottom',
+        # height=6,
+        data=mpg,
+        ax=ax,
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_seaborn_heatmap():
+    """
+    Test seaborn heatmaps. This should work thanks to backwards compatibility support.
+    """
+    fig, ax = pplt.subplots()
+    sns.heatmap(state.normal(size=(50, 50)), ax=ax[0])
+    return fig

ultraplot/tests/test_legend.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+Test legends.
+"""
+import numpy as np, pandas as pd, ultraplot as pplt, pytest
+
+state = np.random.RandomState(51423)
+
+
+@pytest.mark.mpl_image_compare
+def test_auto_legend():
+    """
+    Test retrieval of legends from panels, insets, etc.
+    """
+    fig, ax = pplt.subplots()
+    ax.line(state.rand(5, 3), labels=list("abc"))
+    px = ax.panel_axes("right", share=False)
+    px.linex(state.rand(5, 3), labels=list("xyz"))
+    # px.legend(loc='r')
+    ix = ax.inset_axes((-0.2, 0.8, 0.5, 0.5), zoom=False)
+    ix.line(state.rand(5, 2), labels=list("pq"))
+    ax.legend(loc="b", order="F", edgecolor="red9", edgewidth=3)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_singleton_legend():
+    """
+    Test behavior when singleton lists are passed.
+    Ensure this does not trigger centered-row legends.
+    """
+    fig, ax = pplt.subplots()
+    h1 = ax.plot([0, 1, 2], label="a")
+    h2 = ax.plot([0, 1, 1], label="b")
+    ax.legend(loc="best")
+    ax.legend([h1, h2], loc="bottom")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_centered_legends():
+    """
+    Test success of algorithm.
+    """
+    # Basic centered legends
+    fig, axs = pplt.subplots(ncols=2, nrows=2, axwidth=2)
+    hs = axs[0].plot(state.rand(10, 6))
+    locs = ["l", "t", "r", "uc", "ul", "ll"]
+    locs = ["l", "t", "uc", "ll"]
+    labels = ["a", "bb", "ccc", "ddddd", "eeeeeeee", "fffffffff"]
+    for ax, loc in zip(axs, locs):
+        ax.legend(hs, loc=loc, ncol=3, labels=labels, center=True)
+
+    # Pass centered legends with keywords or list-of-list input.
+    fig, ax = pplt.subplots()
+    hs = ax.plot(state.rand(10, 5), labels=list("abcde"))
+    ax.legend(hs, center=True, loc="b")
+    ax.legend(hs + hs[:1], loc="r", ncol=1)
+    ax.legend([hs[:2], hs[2:], hs[0]], loc="t")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_manual_labels():
+    """
+    Test mixed auto and manual labels. Passing labels but no handles does nothing
+    This is breaking change but probably best. We should not be "guessing" the
+    order objects were drawn in then assigning labels to them. Similar to using
+    OO interface and rejecting pyplot "current axes" and "current figure".
+    """
+    fig, ax = pplt.subplots()
+    (h1,) = ax.plot([0, 1, 2], label="label1")
+    (h2,) = ax.plot([0, 1, 1], label="label2")
+    for loc in ("best", "bottom"):
+        ax.legend([h1, h2], loc=loc, labels=[None, "override"])
+    fig, ax = pplt.subplots()
+    ax.plot([0, 1, 2])
+    ax.plot([0, 1, 1])
+    for loc in ("best", "bottom"):
+        # ax.legend(loc=loc, labels=['a', 'b'])
+        ax.legend(["a", "b"], loc=loc)  # same as above
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_contour_legend_with_label():
+    """
+    Support contour element labels. If has no label should trigger warning.
+    """
+    figs = []
+    label = "label"
+
+    fig, axs = pplt.subplots(ncols=2)
+    ax = axs[0]
+    ax.contour(state.rand(5, 5), color="k", label=label, legend="b")
+    ax = axs[1]
+    ax.pcolor(state.rand(5, 5), label=label, legend="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_contour_legend_without_label():
+    """
+    Support contour element labels. If has no label should trigger warning.
+    """
+    figs = []
+    label = None
+
+    fig, axs = pplt.subplots(ncols=2)
+    ax = axs[0]
+    ax.contour(state.rand(5, 5), color="k", label=label, legend="b")
+    ax = axs[1]
+    ax.pcolor(state.rand(5, 5), label=label, legend="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_histogram_legend():
+    """
+    Support complex histogram legends.
+    """
+    pplt.rc.inlinefmt = "svg"
+    fig, ax = pplt.subplots()
+    res = ax.hist(
+        state.rand(500, 2), 4, labels=("label", "other"), edgefix=True, legend="b"
+    )
+    ax.legend(res, loc="r", ncol=1)  # should issue warning after ignoring numpy arrays
+    df = pd.DataFrame(
+        {"length": [1.5, 0.5, 1.2, 0.9, 3], "width": [0.7, 0.2, 0.15, 0.2, 1.1]},
+        index=["pig", "rabbit", "duck", "chicken", "horse"],
+    )
+    fig, axs = pplt.subplots(ncols=3)
+    ax = axs[0]
+    res = ax.hist(df, bins=3, legend=True, lw=3)
+    ax.legend(loc="b")
+    for ax, meth in zip(axs[1:], ("bar", "area")):
+        hs = getattr(ax, meth)(df, legend="ul", lw=3)
+        ax.legend(hs, loc="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_multiple_calls():
+    """
+    Test successive plotting additions to guides.
+    """
+    fig, ax = pplt.subplots()
+    ax.pcolor(state.rand(10, 10), colorbar="b")
+    ax.pcolor(state.rand(10, 5), cmap="grays", colorbar="b")
+    ax.pcolor(state.rand(10, 5), cmap="grays", colorbar="b")
+
+    fig, ax = pplt.subplots()
+    data = state.rand(10, 5)
+    for i in range(data.shape[1]):
+        ax.plot(data[:, i], colorbar="b", label=f"x{i}", colorbar_kw={"label": "hello"})
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_tuple_handles():
+    """
+    Test tuple legend handles.
+    """
+    from matplotlib import legend_handler
+
+    fig, ax = pplt.subplots(refwidth=3, abc="A.", abcloc="ul", span=False)
+    patches = ax.fill_between(state.rand(10, 3), stack=True)
+    lines = ax.line(1 + 0.5 * (state.rand(10, 3) - 0.5).cumsum(axis=0))
+    # ax.legend([(handles[0], lines[1])], ['joint label'], loc='bottom', queue=True)
+    for hs in (lines, patches):
+        ax.legend(
+            [tuple(hs[:3]) if len(hs) == 3 else hs],
+            ["joint label"],
+            loc="bottom",
+            queue=True,
+            ncol=1,
+            handlelength=4.5,
+            handleheight=1.5,
+            handler_map={tuple: legend_handler.HandlerTuple(pad=0, ndivide=3)},
+        )
+    return fig