ultraplot 0.99.3__py3-none-any.whl

ultraplot/tests/test_colorbar.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+Test colorbars.
+"""
+import numpy as np
+import pytest
+import ultraplot as pplt
+
+state = np.random.RandomState(51423)
+
+
+@pytest.mark.mpl_image_compare
+def test_outer_align():
+    """
+    Test various align options.
+    """
+    fig, ax = pplt.subplots()
+    ax.plot(np.empty((0, 4)), labels=list("abcd"))
+    ax.legend(loc="bottom", align="right", ncol=2)
+    ax.legend(loc="left", align="bottom", ncol=1)
+    ax.colorbar("magma", loc="r", align="top", shrink=0.5, label="label", extend="both")
+    ax.colorbar(
+        "magma",
+        loc="top",
+        ticklen=0,
+        tickloc="bottom",
+        align="left",
+        shrink=0.5,
+        label="Title",
+        extend="both",
+        labelloc="top",
+        labelweight="bold",
+    )
+    ax.colorbar("magma", loc="right", extend="both", label="test extensions")
+    fig.suptitle("Align demo")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_colorbar_ticks():
+    """
+    Test ticks modification.
+    """
+    fig, axs = pplt.subplots(ncols=2)
+    ax = axs[0]
+    ax.colorbar("magma", loc="bottom", ticklen=10, linewidth=3, tickminor=True)
+    ax = axs[1]
+    ax.colorbar(
+        "magma", loc="bottom", ticklen=10, linewidth=3, tickwidth=1.5, tickminor=True
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_discrete_ticks():
+    """
+    Test `DiscreteLocator`.
+    """
+    levels = pplt.arange(0, 2, 0.1)
+    data = state.rand(5, 5) * 2
+    fig, axs = pplt.subplots(share=False, ncols=2, nrows=2, refwidth=2)
+    for i, ax in enumerate(axs):
+        cmd = ax.contourf if i // 2 == 0 else ax.pcolormesh
+        m = cmd(data, levels=levels, extend="both")
+        ax.colorbar(m, loc="t" if i // 2 == 0 else "b")
+        ax.colorbar(m, loc="l" if i % 2 == 0 else "r")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_discrete_vs_fixed():
+    """
+    Test `DiscreteLocator` for numeric on-the-fly
+    mappable ticks and `FixedLocator` otherwise.
+    """
+    fig, axs = pplt.subplots(ncols=2, nrows=3, refwidth=1.3, share=False)
+    axs[0].plot(state.rand(10, 5), labels=list("xyzpq"), colorbar="b")  # fixed
+    axs[1].plot(state.rand(10, 5), labels=np.arange(5), colorbar="b")  # discrete
+    axs[2].contourf(
+        state.rand(10, 10),
+        colorbar="b",
+        colorbar_kw={"ticklabels": list("xyzpq")},  # fixed
+    )
+    axs[3].contourf(state.rand(10, 10), colorbar="b")  # discrete
+    axs[4].pcolormesh(
+        state.rand(10, 10) * 20, colorbar="b", levels=[0, 2, 4, 6, 8, 10, 15, 20]
+    )  # fixed
+    axs[5].pcolormesh(
+        state.rand(10, 10) * 20, colorbar="b", levels=pplt.arange(0, 20, 2)
+    )  # discrete
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_uneven_levels():
+    """
+    Test even and uneven levels with discrete cmap. Ensure minor ticks are disabled.
+    """
+    N = 20
+    state = np.random.RandomState(51423)
+    data = np.cumsum(state.rand(N, N), axis=1) * 12
+    colors = [
+        "white",
+        "indigo1",
+        "indigo3",
+        "indigo5",
+        "indigo7",
+        "indigo9",
+        "yellow1",
+        "yellow3",
+        "yellow5",
+        "yellow7",
+        "yellow9",
+        "violet1",
+        "violet3",
+    ]
+    levels_even = pplt.arange(1, 12, 1)
+    levels_uneven = [1.0, 1.25, 1.5, 2.0, 2.5, 3.0, 3.75, 4.5, 6.0, 7.5, 9.0, 12.0]
+    fig, axs = pplt.subplots(ncols=2, refwidth=3.0)
+    axs[0].pcolor(
+        data, levels=levels_uneven, colors=colors, colorbar="r", extend="both"
+    )
+    axs[1].pcolor(data, levels=levels_even, colors=colors, colorbar="r", extend="both")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_on_the_fly_mappable():
+    """
+    Test on-the-fly mappable generation.
+    """
+    fig, axs = pplt.subplots(ncols=2, nrows=3, space=3)
+    axs.format(aspect=0.5)
+    axs[0].colorbar("magma", vmin=None, vmax=100, values=[0, 1, 2, 3, 4], loc="bottom")
+    axs[1].colorbar("magma", vmin=None, vmax=100, loc="bottom")
+    axs[2].colorbar("colorblind", vmin=None, vmax=None, values=[0, 1, 2], loc="bottom")
+    axs[3].colorbar("colorblind", vmin=None, vmax=None, loc="bottom")
+    axs[4].colorbar(["r", "b", "g", "k", "w"], values=[0, 1, 2], loc="b")
+    axs[5].colorbar(["r", "b", "g", "k", "w"], loc="bottom")
+
+    # Passing labels to plot function.
+    fig, ax = pplt.subplots()
+    ax.scatter(state.rand(10, 4), labels=["foo", "bar", "baz", "xyz"], colorbar="b")
+
+    # Passing string value lists. This helps complete the analogy with legend 'labels'.
+    fig, ax = pplt.subplots()
+    hs = ax.line(state.rand(20, 5))
+    ax.colorbar(hs, loc="b", values=["abc", "def", "ghi", "pqr", "xyz"])
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_inset_colorbars():
+    """
+    Test basic functionality.
+    """
+    # Simple example
+    fig, ax = pplt.subplots()
+    ax.colorbar("magma", loc="ul")
+
+    # Colorbars from lines
+    fig = pplt.figure(share=False, refwidth=2)
+    ax = fig.subplot(121)
+    state = np.random.RandomState(51423)
+    data = 1 + (state.rand(12, 10) - 0.45).cumsum(axis=0)
+    cycle = pplt.Cycle("algae")
+    hs = ax.line(
+        data,
+        lw=4,
+        cycle=cycle,
+        colorbar="lr",
+        colorbar_kw={"length": "8em", "label": "line colorbar"},
+    )
+    ax.colorbar(hs, loc="t", values=np.arange(0, 10), label="line colorbar", ticks=2)
+
+    # Colorbars from a mappable
+    ax = fig.subplot(122)
+    m = ax.contourf(data.T, extend="both", cmap="algae", levels=pplt.arange(0, 3, 0.5))
+    fig.colorbar(
+        m,
+        loc="r",
+        length=1,  # length is relative
+        label="interior ticks",
+        tickloc="left",
+    )
+    ax.colorbar(
+        m,
+        loc="ul",
+        length=6,  # length is em widths
+        label="inset colorbar",
+        tickminor=True,
+        alpha=0.5,
+    )
+    fig.format(
+        suptitle="Colorbar formatting demo",
+        xlabel="xlabel",
+        ylabel="ylabel",
+        titleabove=False,
+    )
+    return fig
+
+
+@pytest.mark.skip("not sure what this does")
+@pytest.mark.mpl_image_compare
+def test_segmented_norm_center():
+    """
+    Test various align options.
+    """
+    fig, ax = pplt.subplots()
+    cmap = pplt.Colormap("NegPos", cut=0.1)
+    data = state.rand(10, 10) * 10 - 2
+    levels = [-4, -3, -2, -1, 0, 1, 2, 4, 8, 16, 32, 64, 128]
+    norm = pplt.SegmentedNorm(levels, vcenter=0, fair=1)
+    ax.pcolormesh(data, levels=levels, norm=norm, cmap=cmap, colorbar="b")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_segmented_norm_ticks():
+    """
+    Ensure segmented norm ticks show up in center when `values` are passed.
+    """
+    fig, ax = pplt.subplots()
+    data = state.rand(10, 10) * 10
+    values = (1, 5, 5.5, 6, 10)
+    ax.contourf(
+        data,
+        values=values,
+        colorbar="ll",
+        colorbar_kw={"tickminor": True, "minorlocator": np.arange(-20, 20, 0.5)},
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_reversed_levels():
+    """
+    Test negative levels with a discrete norm and segmented norm.
+    """
+    fig, axs = pplt.subplots(ncols=4, nrows=2, refwidth=1.8)
+    data = state.rand(20, 20).cumsum(axis=0)
+    i = 0
+    for stride in (1, -1):
+        for key in ("levels", "values"):
+            for levels in (
+                np.arange(0, 15, 1),  # with Normalizer
+                [0, 1, 2, 5, 10, 15],  # with LinearSegmentedNorm
+            ):
+                ax = axs[i]
+                kw = {key: levels[::stride]}
+                ax.pcolormesh(data, colorbar="b", **kw)
+                i += 1
+    return fig

ultraplot/tests/test_docs.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Automatically build pytests from jupytext py:percent documentation files.
+"""
+# import glob
+# import os
+
+# import jupytext
+# import pytest
+
+# from ultraplot.config import rc
+# from ultraplot.tests import SAVEFIG_KWARGS, TOLERANCE, VERSION_STRING
+
+
+# def _init_tests():
+#     """
+#     Construct tests from the jupytext docs examples.
+#     """
+#     # WARNING: This will only work if all jupytext examples consist of single code
+#     # cells or adjacent code cells without intervening markdown or ReST cells.
+#     # Alternative would be to define the entire file as a single test but that
+#     # would make testing and debugging more difficult.
+#     base = os.path.dirname(__file__)
+#     paths = glob.glob(f'{base}/../../docs/*.py')
+#     for path in sorted(paths):
+#         if os.path.basename(path) == 'conf.py':
+#             continue
+#         baseline, _ = os.path.splitext(os.path.basename(path))
+#         result = jupytext.read(path, fmt='py:percent')
+#         cells = result['cells']
+#         source = ''
+#         num = 1
+#         for i, cell in enumerate(cells):
+#             type_ = cell['cell_type']
+#             if type_ == 'code':
+#                 source += '\n' + cell['source']
+#             if not source:
+#                 continue
+#             if i == len(cells) - 1 or type_ != 'code':  # end of example definition
+#                 _make_cell_test(num, baseline, source)
+#                 num += 1
+#         print(f'\nMade {num} tests from file: {path}', end='')
+
+
+# def _make_cell_test(num, baseline, cell_source):
+#     """
+#     Add a test using the jupytext docs cell.
+#     """
+#     # WARNING: Ugly kludge to replace e.g. backend='basemap' with backend='cartopy'
+#     # for matplotlib versions incompatible with basemap. Generally these examples
+#     # test basemap and cartopy side-by-side so this will effectively duplicate the
+#     # cartopy tests but keep us from having to dump them.
+#     if baseline == 'test_projections' and VERSION_STRING == 'mpl32':
+#         cell_source = cell_source.replace("'basemap'", "'cartopy'")
+#         if 'pplt.Proj' in cell_source or 'Table' in cell_source:
+#             return  # examples that cannot be naively converted
+
+#     def run_test():
+#         rc.reset()
+#         exec(cell_source)
+
+#     name = f'{baseline}_cell_{num:02d}'
+#     decorator = pytest.mark.mpl_image_compare(
+#         run_test,
+#         filename=f'{name}_{VERSION_STRING}.png',
+#         baseline_dir='images_docs',
+#         savefig_kwargs=SAVEFIG_KWARGS,
+#         tolerance=TOLERANCE,
+#         style={},  # no mpl style
+#     )
+#     test = decorator(run_test)
+#     name = f'test_{name}'
+#     test.__name__ = test.__qualname__ = name
+#     globals()[name] = test  # for pytest detection
+
+
+# # Initialize functions
+# _init_tests()

ultraplot/tests/test_format.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""
+Test format and rc behavior.
+"""
+import locale, numpy as np, ultraplot as pplt, pytest
+import warnings
+
+state = np.random.RandomState(51423)
+
+
+# def test_colormap_assign():
+#     """
+#     Test below line is possible and naming schemes.
+#     """
+#     pplt.rc["image.cmap"] = pplt.Colormap("phase", shift=180, left=0.2)
+#     assert pplt.rc["cmap"] == pplt.rc["cmap.sequential"] == "_Phase_copy_s"
+#     pplt.rc["image.cmap"] = pplt.Colormap("magma", reverse=True, right=0.8)
+#     assert pplt.rc["image.cmap"] == pplt.rc["cmap.sequential"] == "_magma_copy_r"
+
+
+def test_ignored_keywords():
+    """
+    Test ignored keywords and functions.
+    """
+    with warnings.catch_warnings(record=True) as record:
+        fig, ax = pplt.subplots(
+            gridspec_kw={"left": 3},
+            subplot_kw={"proj": "cart"},
+            subplotpars={"left": 0.2},
+        )
+    assert len(record) == 3
+    with warnings.catch_warnings(record=True) as record:
+        fig.subplots_adjust(left=0.2)
+    assert len(record) == 1
+
+
+@pytest.mark.mpl_image_compare
+def test_init_format():
+    """
+    Test application of format args on initialization.
+    """
+    fig, axs = pplt.subplots(
+        ncols=2,
+        xlim=(0, 10),
+        xlabel="xlabel",
+        abc=True,
+        title="Subplot title",
+        collabels=["Column 1", "Column 2"],
+        suptitle="Figure title",
+    )
+    axs[0].format(hatch="xxx", hatchcolor="k", facecolor="blue3")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_patch_format():
+    """
+    Test application of patch args on initialization.
+    """
+    fig = pplt.figure(suptitle="Super title")
+    fig.subplot(
+        121, proj="cyl", labels=True, land=True, latlines=20, abcloc="l", abc="[A]"
+    )
+    fig.subplot(
+        122,
+        facecolor="gray1",
+        color="red",
+        titleloc="l",
+        title="Hello",
+        abcloc="l",
+        abc="[A]",
+        xticks=0.1,
+        yformatter="scalar",
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_multi_formatting():
+    """
+    Support formatting in multiple projections.
+    """
+    fig, axs = pplt.subplots(ncols=2, proj=("cart", "cyl"))
+    axs[0].pcolormesh(state.rand(5, 5))
+    fig.format(
+        land=1,
+        labels=1,
+        lonlim=(0, 90),
+        latlim=(0, 90),
+        xlim=(0, 10),
+        ylim=(0, 10),
+    )
+    axs[:1].format(
+        land=1,
+        labels=1,
+        lonlim=(0, 90),
+        latlim=(0, 90),
+        xlim=(0, 10),
+        ylim=(0, 10),
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_inner_title_zorder():
+    """
+    Test prominence of contour labels and whatnot.
+    """
+    fig, ax = pplt.subplots()
+    ax.format(
+        title="TITLE", titleloc="upper center", titleweight="bold", titlesize="xx-large"
+    )
+    ax.format(xlim=(0, 1), ylim=(0, 1))
+    ax.text(
+        0.5,
+        0.95,
+        "text",
+        ha="center",
+        va="top",
+        color="red",
+        weight="bold",
+        size="xx-large",
+    )
+    x = [[0.4, 0.6]] * 2
+    y = z = [[0.9, 0.9], [1.0, 1.0]]
+    ax.contour(
+        x,
+        y,
+        z,
+        color="k",
+        labels=True,
+        levels=None,
+        labels_kw={"color": "blue", "weight": "bold", "size": "xx-large"},
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_font_adjustments():
+    """
+    Test font name application. Somewhat hard to do.
+    """
+    fig, axs = pplt.subplots(ncols=2)
+    axs.format(
+        abc="A.",
+        fontsize=15,
+        fontname="Fira Math",
+        xlabel="xlabel",
+        ylabel="ylabel",
+        title="Title",
+        figtitle="Figure title",
+        collabels=["Column 1", "Column 2"],
+    )
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_axes_colors():
+    """
+    Test behavior of passing color to format.
+    """
+    fig, axs = pplt.subplots(
+        ncols=3,
+        nrows=2,
+        share=False,
+        proj=("cyl", "cart", "polar", "cyl", "cart", "polar"),
+        wratios=(2, 2, 1),
+    )
+    axs[:, 0].format(labels=True)
+    axs[:3].format(edgecolor="red", gridlabelsize="med-large", gridlabelweight="bold")
+    axs[:3].format(color="red")  # without this just colors the edge
+    axs[1].format(xticklabelcolor="gray")
+    # axs[2].format(ticklabelcolor='red')
+    axs[1].format(tickcolor="blue")
+    axs[3:].format(color="red")  # ensure propagates
+    # axs[-1].format(gridlabelcolor='green')  # should work
+    return fig
+
+
+@pytest.mark.parametrize("loc", ["en_US.UTF-8"])
+@pytest.mark.mpl_image_compare
+def test_locale_formatting(loc):
+    """
+    Ensure locale formatting works. Also zerotrim should account
+    for non-period decimal separators.
+    """
+    # dealing with read the docs
+    original_locale = locale.getlocale()
+    try:
+        try:
+            locale.setlocale(locale.LC_ALL, loc)
+        except locale.Error:
+            pytest.skip(f"Locale {loc} not available on this system")
+
+        # Your test code that is sensitive to the locale settings
+        assert locale.getlocale() == (loc.split(".")[0], loc.split(".")[1])
+
+        pplt.rc["formatter.use_locale"] = False
+        pplt.rc["formatter.zerotrim"] = True
+        with pplt.rc.context({"formatter.use_locale": True}):
+            fig, ax = pplt.subplots()
+            ticks = pplt.arange(-1, 1, 0.1)
+            ax.format(ylim=(min(ticks), max(ticks)), yticks=ticks)
+        return fig
+    finally:
+        # Always reset to the original locale
+        locale.setlocale(locale.LC_ALL, original_locale)
+    pplt.rc["formatter.use_locale"] = False
+    pplt.rc["formatter.zerotrim"] = True
+    with pplt.rc.context({"formatter.use_locale": True}):
+        fig, ax = pplt.subplots()
+        ticks = pplt.arange(-1, 1, 0.1)
+        ax.format(ylim=(min(ticks), max(ticks)), yticks=ticks)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_bounds_ticks():
+    """
+    Test spine bounds and location. Previously applied `fixticks`
+    automatically but no longer the case.
+    """
+    fig, ax = pplt.subplots()
+    # ax.format(xlim=(-10, 10))
+    ax.format(xloc="top")
+    ax.format(xlim=(-10, 15), xbounds=(0, 10))
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_cutoff_ticks():
+    """
+    Test spine cutoff ticks.
+    """
+    fig, ax = pplt.subplots()
+    # ax.format(xlim=(-10, 10))
+    ax.format(xlim=(-10, 10), xscale=("cutoff", 0, 2), xloc="top", fixticks=True)
+    ax.axvspan(0, 100, facecolor="k", alpha=0.1)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_spine_side():
+    """
+    Test automatic spine selection when passing `xspineloc` or `yspineloc`.
+    """
+    fig, ax = pplt.subplots()
+    ax.plot(pplt.arange(-5, 5), (10 * state.rand(11, 5) - 5).cumsum(axis=0))
+    ax.format(xloc="bottom", yloc="zero")
+    ax.alty(loc="right")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_spine_offset():
+    """
+    Test offset axes.
+    """
+    fig, ax = pplt.subplots()
+    ax.format(xloc="none")  # test none instead of neither
+    ax.alty(loc=("axes", -0.2), color="red")
+    # ax.alty(loc=('axes', 1.2), color='blue')
+    ax.alty(loc=("axes", -0.4), color="blue")
+    ax.alty(loc=("axes", 1.1), color="green")
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_tick_direction():
+    """
+    Test tick direction arguments.
+    """
+    fig, axs = pplt.subplots(ncols=2)
+    axs[0].format(tickdir="in")
+    axs[1].format(xtickdirection="inout", ytickdir="out")  # rc setting should be used?
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_tick_length():
+    """
+    Test tick length args. Ensure ratios can be applied successively.
+    """
+    fig, ax = pplt.subplots()
+    ax.format(yticklen=100)
+    ax.format(xticklen=50, yticklenratio=0.1)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_tick_width():
+    """
+    Test tick width args. Ensure ratios can be applied successively, setting
+    width to `zero` adjusts length for label padding, and ticks can appear
+    without spines if requested.
+    """
+    fig, axs = pplt.subplots(ncols=2, nrows=2, share=False)
+    ax = axs[0]
+    ax.format(linewidth=2, ticklen=20, xtickwidthratio=1)
+    ax.format(ytickwidthratio=0.3)
+    ax = axs[1]
+    ax.format(axeslinewidth=0, ticklen=20, tickwidth=2)  # should permit ticks
+    ax = axs[2]
+    ax.format(tickwidth=0, ticklen=50)  # should set length to zero
+    ax = axs[3]
+    ax.format(linewidth=0, ticklen=20, tickwidth="5em")  # should override linewidth
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_tick_labels():
+    """
+    Test default and overwriting properties of auto tick labels.
+    """
+    import pandas as pd
+
+    data = state.rand(5, 3)
+    data = pd.DataFrame(data, index=["foo", "bar", "baz", "bat", "bot"])
+    fig, axs = pplt.subplots(abc="A.", abcloc="ul", ncols=2, refwidth=3, span=False)
+    for i, ax in enumerate(axs):
+        data.index.name = "label"
+        if i == 1:
+            ax.format(xformatter="null")  # overrides result
+        ax.bar(data, autoformat=True)
+        if i == 0:
+            data.index = ["abc", "def", "ghi", "jkl", "mno"]
+            data.index.name = "foobar"  # label should be updated
+        ax.bar(-data, autoformat=True)
+    return fig
+
+
+@pytest.mark.mpl_image_compare
+def test_label_settings():
+    """
+    Test label colors and ensure color change does not erase labels.
+    """
+    fig, ax = pplt.subplots()
+    ax.format(xlabel="xlabel", ylabel="ylabel")
+    ax.format(labelcolor="red")
+    return fig