ultraplot 2.7.0__tar.gz → 2.7.1__tar.gz

{ultraplot-2.7.0/ultraplot.egg-info → ultraplot-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultraplot
-Version: 2.7.0
+Version: 2.7.1
 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>
@@ -49,7 +49,7 @@ Requires-Dist: mcp<3,>=2.1; extra == "mcp"
 Provides-Extra: stats
 Requires-Dist: scipy; extra == "stats"
 Provides-Extra: typing
-Requires-Dist: basedpyright==1.31.4; extra == "typing"
+Requires-Dist: basedpyright==1.40.1; extra == "typing"
 Dynamic: license-file
 
 .. image:: https://raw.githubusercontent.com/Ultraplot/ultraplot/refs/heads/main/UltraPlotLogo.svg

{ultraplot-2.7.0 → ultraplot-2.7.1}/pyproject.toml

@@ -76,7 +76,7 @@ stats = [
 ]
 
 typing = [
-  "basedpyright==1.31.4",
+  "basedpyright==1.40.1",
 ]
 
 [build-system]

ultraplot-2.7.1/ultraplot/_version.py

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

{ultraplot-2.7.0 → ultraplot-2.7.1}/ultraplot/axes/geo.py

@@ -2900,17 +2900,17 @@ class GeoAxes(shared._SharedAxes, plot.PlotAxes):
             if _is_rectilinear_projection(self):
                 self._add_geoticks("x", lonticklen, ticklen)
                 self._add_geoticks("y", latticklen, ticklen)
-                # If latlim is set to None it resets
-                # the view; this affects the visible range
-                # we need to force this to prevent
-                # side effects
-                if latlim == (None, None):
-                    latlim = self._lataxis.get_view_interval()
-                if lonlim == (None, None):
-                    lonlim = self._lonaxis.get_view_interval()
-                self._update_extent(
-                    lonlim=lonlim, latlim=latlim, boundinglat=boundinglat
-                )
+                # Basemap still installs ticks through Axis.set_ticks(), which can
+                # expand native limits. Cartopy uses FixedLocator and therefore
+                # does not need (and must not receive) this extent reset.
+                if self._name == "basemap":
+                    if latlim == (None, None):
+                        latlim = self._lataxis.get_view_interval()
+                    if lonlim == (None, None):
+                        lonlim = self._lonaxis.get_view_interval()
+                    self._update_extent(
+                        lonlim=lonlim, latlim=latlim, boundinglat=boundinglat
+                    )
             else:
                 warnings._warn_ultraplot(
                     f"Projection is not rectilinear. Ignoring {lonticklen=} and {latticklen=} settings."
@@ -3307,8 +3307,28 @@ class GeoAxes(shared._SharedAxes, plot.PlotAxes):
             # Turn off the ticks otherwise they are double for basemap.
             ax.set_major_formatter(mticker.NullFormatter())
 
-        # Always show the ticks
-        ax.set_ticks(tick_positions)
+        # Always show the ticks. Cartopy gridliner positions are geographic
+        # longitude/latitude coordinates, while the native matplotlib axes use
+        # projection coordinates. Transform them explicitly and install a fixed
+        # locator rather than calling Axis.set_ticks(), which would expand the view
+        # limits to include every tick. Out-of-view fixed ticks are harmless because
+        # Matplotlib filters them at draw time.
+        if self._name == "cartopy":
+            zeros = np.zeros_like(tick_positions)
+            vertices = (
+                np.column_stack((tick_positions, zeros))
+                if x_or_y == "x"
+                else np.column_stack((zeros, tick_positions))
+            )
+            projected = _project_vertices(
+                self,
+                vertices,
+                transform=ccrs.PlateCarree(globe=self.projection.globe),
+            )[:, "xy".index(x_or_y)]
+            projected = projected[np.isfinite(projected)]
+            ax.set_major_locator(mticker.FixedLocator(projected))
+        else:
+            ax.set_ticks(tick_positions)
         ax.set_visible(True)
 
         # Note: set grid_alpha to 0 as it is controlled through the gridlines_major
@@ -4575,14 +4595,14 @@ def _choropleth_iter_rings(geometry: Any) -> Iterator[Any]:
     )
 
 
-def _choropleth_project_vertices(
+def _project_vertices(
     ax: GeoAxes,
     vertices: Any,
     *,
     transform: Any = None,
 ) -> np.ndarray:
     """
-    Project polygon-ring vertices into the target map coordinate system.
+    Project coordinate vertices into the target map coordinate system.
     """
     vertices = np.asarray(vertices, dtype=float)
     xy = vertices[:, :2]
@@ -4590,7 +4610,9 @@ def _choropleth_project_vertices(
         src = transform
         if src is None:
             if ccrs is None:
-                raise RuntimeError("choropleth() requires cartopy for cartopy GeoAxes.")
+                raise RuntimeError(
+                    "Cartopy is required to project Cartopy coordinates."
+                )
             src = ccrs.PlateCarree()
         out = ax.projection.transform_points(src, xy[:, 0], xy[:, 1])
         return np.asarray(out[:, :2], dtype=float)
@@ -4631,7 +4653,7 @@ def _choropleth_geometry_path(
 
     paths = []
     for ring in _choropleth_iter_rings(geometry):
-        projected = _choropleth_project_vertices(ax, ring, transform=transform)
+        projected = _project_vertices(ax, ring, transform=transform)
         path = _choropleth_close_path(projected)
         if path is not None:
             paths.append(path)

{ultraplot-2.7.0 → ultraplot-2.7.1}/ultraplot/colors.py

@@ -536,7 +536,7 @@ def _make_segment_data(values, coords=None, ratios=None):
         coords = np.atleast_1d(coords)
         if ratios is not None:
             warnings._warn_ultraplot(
-                f"Segment coordinates were provided, ignoring " f"ratios={ratios!r}."
+                f"Segment coordinates were provided, ignoring ratios={ratios!r}."
             )
         if len(coords) != len(values) or coords[0] != 0 or coords[-1] != 1:
             raise ValueError(f"Coordinates must range from 0 to 1, got {coords!r}.")
@@ -793,8 +793,7 @@ class _Colormap(object):
             data = "\n".join(" ".join(f"{num:0.6f}" for num in line) for line in data)
         else:
             raise ValueError(
-                f"Invalid extension {ext!r}. Options are: "
-                "'hex', 'txt', 'rgb', 'rgba'."
+                f"Invalid extension {ext!r}. Options are: 'hex', 'txt', 'rgb', 'rgba'."
             )
         return data
 
@@ -3107,6 +3106,29 @@ class ColormapDatabase(mcm.ColormapRegistry):
         # These are converted to ultraplot's own colormap objects
         # on the fly when they are first accessed.
 
+    def __contains__(self, key):
+        # Work around for mpl 3.11.2 as it is not allowed to
+        # this piece of code will allow look up to both occur in our flattened representation (e.g. 'fire') as well as the original "Fire"
+        try:
+            key = self._translate_deprecated(key)
+            key = self._translate_key(key, mirror=True)
+        except (KeyError, TypeError, ValueError):
+            return False
+
+        # Directly registered colormap
+        if self._has_item(key):
+            return True
+
+        # Dynamically generated shifted colormap
+        if key.endswith("_s"):
+            key = key.removesuffix("_s")
+
+        # Dynamically generated reversed colormap
+        if key.endswith("_r"):
+            key = key.removesuffix("_r")
+
+        return self._has_item(key)
+
     def _translate_deprecated(self, key):
         """
         Check if a colormap has been deprecated.

{ultraplot-2.7.0 → ultraplot-2.7.1}/ultraplot/tests/test_colormap.py

@@ -1,4 +1,7 @@
-import ultraplot as uplt, pytest, numpy as np
+import numpy as np
+import pytest
+
+import ultraplot as uplt
 
 
 def test_colormap_reversal():
@@ -10,3 +13,13 @@ def test_colormap_reversal():
         assert np.allclose(
             cmap(i), cmap_r(255 - i)
         ), f"Reversed colormap mismatch at index {i}"
+
+
+def test_colormap_name_sensitivty():
+    assert "fire" in uplt.colormaps
+    assert "Fire" in uplt.colormaps
+    assert "fire_r" in uplt.colormaps
+    assert "fire_s" in uplt.colormaps
+
+    with pytest.raises(KeyError):
+        uplt.colormaps["should_not_exist"]

{ultraplot-2.7.0 → ultraplot-2.7.1}/ultraplot/tests/test_geographic.py

@@ -1697,6 +1697,112 @@ def test_sharing_cartopy_with_colorbar(rng):
     return fig
 
 
+@pytest.mark.parametrize("proj", ("cyl", "merc", "lcyl", "mill"))
+@pytest.mark.parametrize("ticklen", (0.5, 1, 2))
+@pytest.mark.parametrize(
+    ("lonlim", "latlim"),
+    [
+        (None, None),
+        ((95, 200), (10, 40)),
+    ],
+)
+def test_geoticks_rectangular_projection_coordinates(proj, ticklen, lonlim, latlim):
+    """
+    Geographic ticks should be transformed into native projection coordinates.
+    """
+    pytest.importorskip("cartopy")
+    fig, axs = uplt.subplots(proj=proj, proj_kw={"lon0": 180})
+    kwargs = {}
+    if lonlim is not None:
+        kwargs.update(lonlim=lonlim, latlim=latlim)
+    axs.format(
+        coast=True,
+        lonlabels=True,
+        latlabels=True,
+        ticklen=ticklen,
+        **kwargs,
+    )
+
+    ax = axs[0]
+    xlim = np.asarray(ax.get_xlim())
+    ylim = np.asarray(ax.get_ylim())
+    assert np.all(np.isfinite(xlim))
+    assert np.all(np.isfinite(ylim))
+    assert np.diff(xlim)[0] > 0
+    assert np.diff(ylim)[0] > 0
+    crs = uplt.axes.geo.ccrs.PlateCarree(globe=ax.projection.globe)
+    lon_ticks = ax._gridliner_tick_positions("x", which="major")
+    lat_ticks = ax._gridliner_tick_positions("y", which="major")
+    expected_x = ax.projection.transform_points(
+        crs,
+        lon_ticks,
+        np.zeros_like(lon_ticks),
+    )[:, 0]
+    expected_y = ax.projection.transform_points(
+        crs,
+        np.zeros_like(lat_ticks),
+        lat_ticks,
+    )[:, 1]
+    expected_x = expected_x[np.isfinite(expected_x)]
+    expected_y = expected_y[np.isfinite(expected_y)]
+    assert np.allclose(
+        np.sort(np.asarray(ax.get_xticks())),
+        np.sort(expected_x),
+        atol=1e-6,
+    )
+    assert np.allclose(
+        np.sort(np.asarray(ax.get_yticks())),
+        np.sort(expected_y),
+        atol=1e-6,
+    )
+
+    fig.canvas.draw()
+    uplt.close(fig)
+
+
+@pytest.mark.parametrize("proj", ("cyl", "merc", "lcyl", "mill"))
+def test_geoticks_do_not_change_projected_view_limits(proj):
+    """
+    Adding geographic ticks must not expand the native projected view limits.
+    """
+    pytest.importorskip("cartopy")
+    fig, axs = uplt.subplots(proj=proj, proj_kw={"lon0": 180})
+    ax = axs[0]
+    ax.format(coast=True, lonlabels=True, latlabels=True)
+    before_xlim = np.asarray(ax.get_xlim()).copy()
+    before_ylim = np.asarray(ax.get_ylim()).copy()
+
+    ax.format(ticklen=2)
+
+    assert np.allclose(ax.get_xlim(), before_xlim, atol=1e-6)
+    assert np.allclose(ax.get_ylim(), before_ylim, atol=1e-6)
+    fig.canvas.draw()
+    uplt.close(fig)
+
+
+@pytest.mark.parametrize("proj", ("robin", "moll", "ortho"))
+def test_geoticks_non_rectilinear_projection_unchanged(proj):
+    """
+    Tick lengths remain unsupported on curved projections and must not alter ticks.
+    """
+    pytest.importorskip("cartopy")
+    fig, axs = uplt.subplots(proj=proj)
+    ax = axs[0]
+    xticks = np.asarray(ax.get_xticks()).copy()
+    yticks = np.asarray(ax.get_yticks()).copy()
+
+    with pytest.warns(
+        uplt.warnings.UltraPlotWarning,
+        match="Projection is not rectilinear",
+    ):
+        ax.format(ticklen=1)
+
+    assert np.array_equal(np.asarray(ax.get_xticks()), xticks)
+    assert np.array_equal(np.asarray(ax.get_yticks()), yticks)
+    fig.canvas.draw()
+    uplt.close(fig)
+
+
 def test_consistent_range():
     """
     Check if the extent of the axes is consistent

{ultraplot-2.7.0 → ultraplot-2.7.1/ultraplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultraplot
-Version: 2.7.0
+Version: 2.7.1
 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>
@@ -49,7 +49,7 @@ Requires-Dist: mcp<3,>=2.1; extra == "mcp"
 Provides-Extra: stats
 Requires-Dist: scipy; extra == "stats"
 Provides-Extra: typing
-Requires-Dist: basedpyright==1.31.4; extra == "typing"
+Requires-Dist: basedpyright==1.40.1; extra == "typing"
 Dynamic: license-file
 
 .. image:: https://raw.githubusercontent.com/Ultraplot/ultraplot/refs/heads/main/UltraPlotLogo.svg

{ultraplot-2.7.0 → ultraplot-2.7.1}/ultraplot.egg-info/requires.txt

@@ -35,4 +35,4 @@ mcp<3,>=2.1
 scipy
 
 [typing]
-basedpyright==1.31.4
+basedpyright==1.40.1

ultraplot-2.7.0/ultraplot/_version.py

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