ultraplot 2.1.0__tar.gz → 2.1.2__tar.gz

{ultraplot-2.1.0/ultraplot.egg-info → ultraplot-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultraplot
-Version: 2.1.0
+Version: 2.1.2
 Summary: A succinct matplotlib wrapper for making beautiful, publication-quality graphics.
 Author-email: Casper van Elteren <caspervanelteren@gmail.com>, Luke Davis <lukelbd@gmail.com>
 Maintainer-email: Casper van Elteren <caspervanelteren@gmail.com>, "Matthew R. Becker" <becker.mr@gmail.com>

{ultraplot-2.1.0 → ultraplot-2.1.2}/codecov.yml

@@ -23,6 +23,8 @@ coverage:
           - "!logo/*"
           - "!docs/*"
           - "!ultraplot/tests/*"
+          - "!ultraplot/demos.py"
+
 
       tests:
         target: 95.0%

ultraplot-2.1.2/ultraplot/_version.py

@@ -0,0 +1 @@
+__version__ = '2.1.2'

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/axes/base.py

@@ -3149,19 +3149,31 @@ class Axes(_ExternalModeMixin, maxes.Axes):
             self._colorbar_fill.update_ticks(manual_only=True)  # only if needed
         if self._inset_parent is not None and self._inset_zoom:
             self.indicate_inset_zoom()
+        needs_inset_reflow = bool(getattr(self, "_inset_colorbar_needs_reflow", False))
+        has_inset_frame = bool(
+            getattr(self, "_inset_colorbar_frame", None) is not None
+            and getattr(self, "_inset_colorbar_obj", None)
+        )
         super().draw(renderer, *args, **kwargs)
-        if getattr(self, "_inset_colorbar_obj", None) and getattr(
-            self, "_inset_colorbar_needs_reflow", False
-        ):
-            self._inset_colorbar_needs_reflow = False
+        if has_inset_frame:
+            if not needs_inset_reflow:
+                needs_inset_reflow = _inset_colorbar_frame_needs_reflow(
+                    self._inset_colorbar_obj,
+                    labelloc=getattr(self, "_inset_colorbar_labelloc", None),
+                    renderer=renderer,
+                )
+        if has_inset_frame and needs_inset_reflow:
             _reflow_inset_colorbar_frame(
                 self._inset_colorbar_obj,
                 labelloc=getattr(self, "_inset_colorbar_labelloc", None),
                 ticklen=getattr(
                     self, "_inset_colorbar_ticklen", units(rc["tick.len"], "pt")
                 ),
+                renderer=renderer,
             )
-            self.figure.canvas.draw_idle()
+            self._inset_colorbar_needs_reflow = False
+            # Re-draw synchronously so the current render pass sees reflowed bounds.
+            super().draw(renderer, *args, **kwargs)
 
     def get_tightbbox(self, renderer, *args, **kwargs):
         # Perform extra post-processing steps
@@ -4581,11 +4593,71 @@ def _apply_inset_colorbar_layout(
         frame.set_bounds(*bounds_frame)
 
 
+def _inset_colorbar_frame_needs_reflow(colorbar, *, labelloc: str, renderer) -> bool:
+    cax = colorbar.ax
+    layout = getattr(cax, "_inset_colorbar_layout", None)
+    frame = getattr(cax, "_inset_colorbar_frame", None)
+    if not layout or frame is None:
+        return False
+
+    orientation = layout["orientation"]
+    loc = layout["loc"]
+    ticklocation = layout["ticklocation"]
+    labelloc_layout = labelloc if isinstance(labelloc, str) else ticklocation
+    bboxes = []
+
+    longaxis = _get_colorbar_long_axis(colorbar)
+    try:
+        bbox = longaxis.get_tightbbox(renderer)
+    except Exception:
+        bbox = None
+    if bbox is not None:
+        bboxes.append(bbox)
+
+    label_axis = _get_axis_for(
+        labelloc_layout, loc, orientation=orientation, ax=colorbar
+    )
+    if label_axis.label.get_text():
+        try:
+            bboxes.append(label_axis.label.get_window_extent(renderer=renderer))
+        except Exception:
+            pass
+
+    for artist in (
+        getattr(colorbar, "outline", None),
+        getattr(colorbar, "solids", None),
+        getattr(colorbar, "dividers", None),
+    ):
+        if artist is None:
+            continue
+        try:
+            bboxes.append(artist.get_window_extent(renderer=renderer))
+        except Exception:
+            pass
+
+    if not bboxes:
+        return False
+
+    x0 = min(bbox.x0 for bbox in bboxes)
+    y0 = min(bbox.y0 for bbox in bboxes)
+    x1 = max(bbox.x1 for bbox in bboxes)
+    y1 = max(bbox.y1 for bbox in bboxes)
+    frame_bbox = frame.get_window_extent(renderer=renderer)
+    tol = 1.0
+    return (
+        frame_bbox.x0 > x0 + tol
+        or frame_bbox.y0 > y0 + tol
+        or frame_bbox.x1 < x1 - tol
+        or frame_bbox.y1 < y1 - tol
+    )
+
+
 def _reflow_inset_colorbar_frame(
     colorbar,
     *,
     labelloc: str,
     ticklen: float,
+    renderer=None,
 ):
     cax = colorbar.ax
     layout = getattr(cax, "_inset_colorbar_layout", None)
@@ -4623,7 +4695,7 @@ def _reflow_inset_colorbar_frame(
         cb_width = width
         cb_height = length
 
-    renderer = cax.figure._get_renderer()
+    renderer = renderer or cax.figure._get_renderer()
     if hasattr(colorbar, "update_ticks"):
         colorbar.update_ticks(manual_only=True)
     bboxes = []

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/axes/plot.py

@@ -4141,6 +4141,7 @@ class PlotAxes(base.Axes):
         # NOTE: Unlike xarray, but like matplotlib, vmin and vmax only approximately
         # determine level range. Levels are selected with Locator.tick_values().
         levels = None  # unused
+        explicit_limits = False
         isdiverging = False
         if not discrete and not skip_autolev:
             vmin, vmax, kwargs = self._parse_level_lim(
@@ -4150,7 +4151,15 @@ class PlotAxes(base.Axes):
                 if abs(np.sign(vmax) - np.sign(vmin)) == 2:
                     isdiverging = True
         if discrete:
-            levels, vmin, vmax, norm, norm_kw, kwargs = self._parse_level_vals(
+            (
+                levels,
+                vmin,
+                vmax,
+                norm,
+                norm_kw,
+                explicit_limits,
+                kwargs,
+            ) = self._parse_level_vals(
                 *args,
                 vmin=vmin,
                 vmax=vmax,
@@ -4199,6 +4208,7 @@ class PlotAxes(base.Axes):
                 center_levels=center_levels,
                 extend=extend,
                 min_levels=min_levels,
+                explicit_limits=explicit_limits,
                 **kwargs,
             )
         params = _pop_params(kwargs, *self._level_parsers, ignore_internal=True)
@@ -4462,7 +4472,6 @@ class PlotAxes(base.Axes):
         center_levels = _not_none(center_levels, rc["colorbar.center_levels"])
         vmin = _not_none(vmin=vmin, norm_kw_vmin=norm_kw.pop("vmin", None))
         vmax = _not_none(vmax=vmax, norm_kw_vmax=norm_kw.pop("vmax", None))
-        norm = constructor.Norm(norm or "linear", **norm_kw)
         symmetric = _not_none(
             symmetric=symmetric,
             locator_kw_symmetric=locator_kw.pop("symmetric", None),
@@ -4555,6 +4564,8 @@ class PlotAxes(base.Axes):
         nozero=False,
         norm=None,
         norm_kw=None,
+        vmin=None,
+        vmax=None,
         skip_autolev=False,
         min_levels=None,
         center_levels=None,
@@ -4577,7 +4588,9 @@ class PlotAxes(base.Axes):
             Whether to remove out non-positive, non-negative, and zero-valued
             levels. The latter is useful for single-color contour plots.
         norm, norm_kw : optional
-            Passed to `Norm`. Used to possbily infer levels or to convert values.
+            Passed to `Norm`. Used to possibly infer levels or to convert values.
+        vmin, vmax : float, optional
+            The user input normalization range.
         skip_autolev : bool, optional
             Whether to skip automatic level generation.
         min_levels : int, optional
@@ -4587,6 +4600,8 @@ class PlotAxes(base.Axes):
         -------
         levels : list of float
             The level edges.
+        explicit_limits : bool
+            Whether the user explicitly provided `vmin` and/or `vmax`.
         **kwargs
             Unused arguments.
         """
@@ -4625,7 +4640,9 @@ class PlotAxes(base.Axes):
             return array
 
         # Parse input arguments and resolve incompatibilities
-        vmin = vmax = None
+        explicit_limits = vmin is not None or vmax is not None
+        line_contours = min_levels == 1
+        keep_explicit_line_limits = line_contours and explicit_limits
         levels = _not_none(N=N, levels=levels, norm_kw_levs=norm_kw.pop("levels", None))
         if positive and negative:
             warnings._warn_ultraplot(
@@ -4684,6 +4701,8 @@ class PlotAxes(base.Axes):
             levels, kwargs = self._parse_level_num(
                 *args,
                 levels=levels,
+                vmin=vmin,
+                vmax=vmax,
                 norm=norm,
                 norm_kw=norm_kw,
                 extend=extend,
@@ -4696,8 +4715,8 @@ class PlotAxes(base.Axes):
             levels = values = None
 
         # Determine default colorbar locator and norm and apply filters
-        # NOTE: DiscreteNorm does not currently support vmin and
-        # vmax different from level list minimum and maximum.
+        # NOTE: Preserve explicit vmin/vmax only for line contours, where levels
+        # represent contour values rather than filled bins.
         # NOTE: The level restriction should have no effect if levels were generated
         # automatically. However want to apply these to manual-input levels as well.
         if levels is not None:
@@ -4705,15 +4724,21 @@ class PlotAxes(base.Axes):
             if len(levels) == 0:  # skip
                 pass
             elif len(levels) == 1:  # use central colormap color
-                vmin, vmax = levels[0] - 1, levels[0] + 1
+                if not keep_explicit_line_limits or vmin is None:
+                    vmin = levels[0] - 1
+                if not keep_explicit_line_limits or vmax is None:
+                    vmax = levels[0] + 1
             else:  # use minimum and maximum
-                vmin, vmax = np.min(levels), np.max(levels)
+                if not keep_explicit_line_limits or vmin is None:
+                    vmin = np.min(levels)
+                if not keep_explicit_line_limits or vmax is None:
+                    vmax = np.max(levels)
                 if not np.allclose(levels[1] - levels[0], np.diff(levels)):
                     norm = _not_none(norm, "segmented")
             if norm in ("segments", "segmented"):
                 norm_kw["levels"] = levels
 
-        return levels, vmin, vmax, norm, norm_kw, kwargs
+        return levels, vmin, vmax, norm, norm_kw, explicit_limits, kwargs
 
     @staticmethod
     def _parse_level_norm(
@@ -4726,6 +4751,7 @@ class PlotAxes(base.Axes):
         discrete_ticks=None,
         discrete_labels=None,
         center_levels=None,
+        explicit_limits=False,
         **kwargs,
     ):
         """
@@ -4748,11 +4774,14 @@ class PlotAxes(base.Axes):
             The colorbar locations to tick.
         discrete_labels : array-like, optional
             The colorbar tick labels.
+        explicit_limits : bool, optional
+            Whether `vmin`/`vmax` were explicitly provided by the user.
 
         Returns
         -------
-        norm : `~ultraplot.colors.DiscreteNorm`
-            The discrete normalizer.
+        norm : `~ultraplot.colors.DiscreteNorm` or `~matplotlib.colors.Normalize`
+            The discrete normalizer, or the original continuous normalizer when
+            line contours have explicit limits or use qualitative color lists.
         cmap : `~matplotlib.colors.Colormap`
             The possibly-modified colormap.
         kwargs
@@ -4814,10 +4843,16 @@ class PlotAxes(base.Axes):
                 elif extend == "max":
                     unique = "neither"
 
-        # Generate DiscreteNorm and update "child" norm with vmin and vmax from
-        # levels. This lets the colorbar set tick locations properly!
+        # Generate DiscreteNorm for filled-contour style bins. For line contours
+        # with explicit limits or qualitative color lists, keep the continuous
+        # normalizer to preserve one-to-one value->color mapping.
         center_levels = _not_none(center_levels, rc["colorbar.center_levels"])
-        if not isinstance(norm, mcolors.BoundaryNorm) and len(levels) > 1:
+        preserve_line_mapping = min_levels == 1 and (explicit_limits or qualitative)
+        if (
+            not preserve_line_mapping
+            and not isinstance(norm, mcolors.BoundaryNorm)
+            and len(levels) > 1
+        ):
             norm = pcolors.DiscreteNorm(
                 levels,
                 norm=norm,

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/colorbar.py

@@ -347,7 +347,9 @@ class UltraColorbar:
             cax._inset_colorbar_obj = obj
             cax._inset_colorbar_labelloc = labelloc
             cax._inset_colorbar_ticklen = ticklen
-            _register_inset_colorbar_reflow(ax.figure)
+            has_frame = getattr(cax, "_inset_colorbar_frame", None) is not None
+            if has_frame:
+                _register_inset_colorbar_reflow(ax.figure)
         kw_outline = {"edgecolor": color, "linewidth": linewidth}
         if obj.outline is not None:
             obj.outline.update(kw_outline)
@@ -958,6 +960,7 @@ def _reflow_inset_colorbar_frame(
     *,
     labelloc: Optional[str],
     ticklen: float,
+    renderer=None,
 ):
     cax = colorbar.ax
     layout = getattr(cax, "_inset_colorbar_layout", None)
@@ -995,7 +998,7 @@ def _reflow_inset_colorbar_frame(
         cb_width = width
         cb_height = length
 
-    renderer = cax.figure._get_renderer()
+    renderer = renderer or cax.figure._get_renderer()
     if hasattr(colorbar, "update_ticks"):
         colorbar.update_ticks(manual_only=True)
     bboxes = []

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/gridspec.py

@@ -1988,9 +1988,11 @@ class SubplotGrid(MutableSequence, list):
         elif not isinstance(objs, list):
             objs = [objs]
 
+        # Spanning subplots can appear more than once in the sliced slot grid.
+        # De-duplicate while preserving order so method dispatch does not repeat.
+        objs = list(dict.fromkeys(objs))
         if len(objs) == 1:
             return objs[0]
-        objs = [obj for obj in objs if obj is not None]
         return SubplotGrid(objs)
 
     def __setitem__(self, key, value):

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/internals/__init__.py

@@ -4,6 +4,7 @@ Internal utilities.
 """
 
 # Import statements
+import functools
 import inspect
 from importlib import import_module
 from numbers import Integral, Real
@@ -155,6 +156,40 @@ _alias_maps = {
     },
 }
 
+
+_INTERNAL_POP_PARAMS = frozenset(
+    {
+        "default_cmap",
+        "default_discrete",
+        "inbounds",
+        "plot_contours",
+        "plot_lines",
+        "skip_autolev",
+        "to_centers",
+    }
+)
+
+
+@functools.lru_cache(maxsize=256)
+def _signature_cached(func):
+    """
+    Cache inspect.signature lookups for hot utility paths.
+    """
+    return inspect.signature(func)
+
+
+def _get_signature(func):
+    """
+    Return a signature, normalizing bound methods to their underlying function.
+    """
+    key = getattr(func, "__func__", func)
+    try:
+        return _signature_cached(key)
+    except TypeError:
+        # Some callable objects may be unhashable for lru_cache keys.
+        return inspect.signature(func)
+
+
 _LAZY_ATTRS = {
     "benchmarks": ("benchmarks", None),
     "context": ("context", None),
@@ -224,28 +259,19 @@ def _pop_params(kwargs, *funcs, ignore_internal=False):
     """
     Pop parameters of the input functions or methods.
     """
-    internal_params = {
-        "default_cmap",
-        "default_discrete",
-        "inbounds",
-        "plot_contours",
-        "plot_lines",
-        "skip_autolev",
-        "to_centers",
-    }
     output = {}
     for func in funcs:
         if isinstance(func, inspect.Signature):
             sig = func
         elif callable(func):
-            sig = inspect.signature(func)
+            sig = _get_signature(func)
         elif func is None:
             continue
         else:
             raise RuntimeError(f"Internal error. Invalid function {func!r}.")
         for key in sig.parameters:
             value = kwargs.pop(key, None)
-            if ignore_internal and key in internal_params:
+            if ignore_internal and key in _INTERNAL_POP_PARAMS:
                 continue
             if value is not None:
                 output[key] = value

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/tests/test_2dplots.py

@@ -6,6 +6,7 @@ Test 2D plotting overrides.
 import numpy as np
 import pytest
 import xarray as xr
+from matplotlib.colors import Normalize
 
 import ultraplot as uplt, warnings
 
@@ -291,6 +292,126 @@ def test_levels_with_vmin_vmax(rng):
     return fig
 
 
+def test_contour_levels_respect_explicit_vmin_vmax():
+    """
+    Explicit `vmin` and `vmax` should be preserved for line contours.
+    """
+    data = np.linspace(0, 10, 25).reshape((5, 5))
+    levels = [2, 4, 6]
+    _, ax = uplt.subplots()
+    m = ax.contour(data, levels=levels, cmap="viridis", vmin=0, vmax=10)
+    assert m.norm.vmin == pytest.approx(0)
+    assert m.norm.vmax == pytest.approx(10)
+    assert m.norm(3) == pytest.approx(0.3)
+    assert m.norm(5) == pytest.approx(0.5)
+
+
+def test_contour_levels_default_stretch():
+    """
+    Without explicit limits, level bins should continue to span full cmap range.
+    """
+    data = np.linspace(0, 10, 25).reshape((5, 5))
+    levels = [2, 4, 6]
+    _, ax = uplt.subplots()
+    m = ax.contourf(data, levels=levels, cmap="viridis")
+    assert m.norm(3) == pytest.approx(0.0)
+    assert m.norm(5) == pytest.approx(1.0)
+
+
+def test_contour_levels_default_use_discrete_norm():
+    """
+    Line contours should retain DiscreteNorm behavior unless limits are explicit.
+    """
+    data = np.linspace(0, 10, 25).reshape((5, 5))
+    levels = [2, 4, 6]
+    _, ax = uplt.subplots()
+    m = ax.contour(data, levels=levels, cmap="viridis")
+    assert hasattr(m.norm, "_norm")
+    assert m.norm(3) == pytest.approx(0.0)
+    assert m.norm(5) == pytest.approx(1.0)
+
+
+def test_contourf_levels_keep_level_range_with_explicit_vmin_vmax():
+    """
+    Filled contour bins keep level-based discrete scaling.
+    """
+    data = np.linspace(0, 10, 25).reshape((5, 5))
+    levels = [2, 4, 6]
+    _, ax = uplt.subplots()
+    m = ax.contourf(data, levels=levels, cmap="viridis", vmin=0, vmax=10)
+    assert m.norm.vmin == pytest.approx(2)
+    assert m.norm.vmax == pytest.approx(6)
+    assert m.norm._norm.vmin == pytest.approx(2)
+    assert m.norm._norm.vmax == pytest.approx(6)
+    assert m.norm(3) == pytest.approx(0.0)
+    assert m.norm(5) == pytest.approx(1.0)
+
+
+def test_contour_explicit_colors_match_levels():
+    """
+    Explicit contour line colors should map one-to-one with contour levels.
+    """
+    x = np.linspace(-1, 1, 100)
+    y = np.linspace(-1, 1, 100)
+    X, Y = np.meshgrid(x, y)
+    Z = np.exp(-(X**2 + Y**2))
+    levels = [0.3, 0.6, 0.9]
+    turbo = uplt.Colormap("turbo")
+    colors = turbo(Normalize(vmin=0, vmax=1)(levels))
+    _, ax = uplt.subplots()
+    m = ax.contour(X, Y, Z, levels=levels, colors=colors, linewidths=1)
+    assert np.allclose(np.asarray(m.get_edgecolor()), colors)
+
+
+def test_tricontour_default_use_discrete_norm():
+    """
+    Triangular line contours should default to DiscreteNorm bin mapping.
+    """
+    rng = np.random.default_rng(51423)
+    x = rng.random(40)
+    y = rng.random(40)
+    z = np.sin(3 * x) + np.cos(3 * y)
+    levels = [-1.0, 0.0, 1.0]
+    _, ax = uplt.subplots()
+    m = ax.tricontour(x, y, z, levels=levels, cmap="viridis")
+    assert hasattr(m.norm, "_norm")
+    assert m.norm(-0.5) == pytest.approx(0.0)
+    assert m.norm(0.5) == pytest.approx(1.0)
+
+
+def test_tricontour_levels_respect_explicit_vmin_vmax():
+    """
+    Triangular line contours preserve explicit normalization limits.
+    """
+    rng = np.random.default_rng(51423)
+    x = rng.random(40)
+    y = rng.random(40)
+    z = np.sin(3 * x) + np.cos(3 * y)
+    levels = [-1.0, 0.0, 1.0]
+    _, ax = uplt.subplots()
+    m = ax.tricontour(x, y, z, levels=levels, cmap="viridis", vmin=-2, vmax=2)
+    assert m.norm.vmin == pytest.approx(-2)
+    assert m.norm.vmax == pytest.approx(2)
+    assert m.norm(-0.5) == pytest.approx(0.375)
+    assert m.norm(0.5) == pytest.approx(0.625)
+
+
+def test_tricontour_explicit_colors_match_levels():
+    """
+    Explicit triangular contour colors should map one-to-one with levels.
+    """
+    rng = np.random.default_rng(51423)
+    x = rng.random(40)
+    y = rng.random(40)
+    z = np.sin(3 * x) + np.cos(3 * y)
+    levels = [-1.0, 0.0, 1.0]
+    turbo = uplt.Colormap("turbo")
+    colors = turbo(Normalize(vmin=-2, vmax=2)(levels))
+    _, ax = uplt.subplots()
+    m = ax.tricontour(x, y, z, levels=levels, colors=colors, linewidths=1)
+    assert np.allclose(np.asarray(m.get_edgecolor()), colors)
+
+
 @pytest.mark.mpl_image_compare
 def test_level_restriction(rng):
     """

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/tests/test_colorbar.py

@@ -97,6 +97,37 @@ def test_inset_colorbar_frame_wraps_label(rng, orientation, labelloc):
     assert frame_bbox.y1 >= label_bbox.y1 - tol
 
 
+def test_inset_colorbar_frame_wraps_label_with_refaspect(rng):
+    """
+    Inset colorbar frame should include the label when figure sizing is refaspect-driven.
+    """
+    from ultraplot.axes.base import _get_axis_for
+
+    fig, ax = uplt.subplots(refaspect=2)
+    data = rng.random((20, 30))
+    m = ax.pcolormesh(data, vmin=0, vmax=1)
+    cb = ax.colorbar(m, loc="ul", label="title", frameon=True)
+    fig.canvas.draw()
+
+    frame = cb.ax._inset_colorbar_frame
+    assert frame is not None
+
+    renderer = fig.canvas.get_renderer()
+    frame_bbox = frame.get_window_extent(renderer)
+    layout = cb.ax._inset_colorbar_layout
+    labelloc = cb.ax._inset_colorbar_labelloc
+    labelloc_layout = labelloc if isinstance(labelloc, str) else layout["ticklocation"]
+    label_axis = _get_axis_for(
+        labelloc_layout, layout["loc"], orientation=layout["orientation"], ax=cb
+    )
+    label_bbox = label_axis.label.get_window_extent(renderer)
+    tol = 1.0
+    assert frame_bbox.x0 <= label_bbox.x0 + tol
+    assert frame_bbox.x1 >= label_bbox.x1 - tol
+    assert frame_bbox.y0 <= label_bbox.y0 + tol
+    assert frame_bbox.y1 >= label_bbox.y1 - tol
+
+
 from itertools import product
 
 

{ultraplot-2.1.0 → ultraplot-2.1.2}/ultraplot/tests/test_gridspec.py

@@ -126,3 +126,22 @@ def test_gridspec_slicing():
     # subset_mixed[4] -> Row 1, Col 0 -> Number 5 (since 4 cols per row)
     assert subset_mixed[0].number == 1
     assert subset_mixed[4].number == 5
+
+
+def test_gridspec_spanning_slice_deduplicates_axes():
+    import numpy as np
+
+    fig, axs = uplt.subplots(np.array([[1, 1, 2], [3, 4, 5]]))
+
+    # The first two slots in the top row refer to the same spanning subplot.
+    ax = axs[0, :2]
+    assert isinstance(ax, uplt.axes.Axes)
+    assert ax is axs[0, 0]
+
+    data = np.array([[0.1, 0.2], [0.4, 0.5], [0.7, 0.8]])
+    ax.scatter(data[:, 0], data[:, 1], c="grey", label="data", legend=True)
+    fig.canvas.draw()
+
+    legend = ax.get_legend()
+    assert legend is not None
+    assert [t.get_text() for t in legend.texts] == ["data"]

{ultraplot-2.1.0 → ultraplot-2.1.2/ultraplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultraplot
-Version: 2.1.0
+Version: 2.1.2
 Summary: A succinct matplotlib wrapper for making beautiful, publication-quality graphics.
 Author-email: Casper van Elteren <caspervanelteren@gmail.com>, Luke Davis <lukelbd@gmail.com>
 Maintainer-email: Casper van Elteren <caspervanelteren@gmail.com>, "Matthew R. Becker" <becker.mr@gmail.com>

ultraplot-2.1.0/ultraplot/_version.py

@@ -1 +0,0 @@
-__version__ = '2.1.0'