Merge branch 'main' into doc/ecosystem

Author: seisman

.github/workflows/ci_tests_dev.yaml

@@ -36,7 +36,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-24.04, macos-14, windows-2022]
+        os: [ubuntu-24.04, macos-15, windows-2022]
         gmt_git_ref: [master]
     timeout-minutes: 30
     defaults:

doc/_templates/footer.html

@@ -3,7 +3,7 @@
 
 {%- block extrafooter %}
 <p>
-Built with <a href="https://sphinx-doc.org/">Sphinx</a>
+Built with <a href="https://www.sphinx-doc.org/">Sphinx</a>
 using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a>
 provided by <a href="https://readthedocs.org">Read the Docs</a>
 </p>

pygmt/accessors.py

@@ -2,6 +2,7 @@
 GMT accessor for :class:`xarray.DataArray`.
 """
 
+import contextlib
 from pathlib import Path
 
 import xarray as xr
@@ -115,22 +116,17 @@ class GMTDataArrayAccessor:
 
     def __init__(self, xarray_obj):
         self._obj = xarray_obj
-
-        self._source = self._obj.encoding.get("source")
-        if self._source is not None and Path(self._source).exists():
-            try:
-                # Get grid registration and grid type from the last two columns
-                # of the shortened summary information of `grdinfo`.
+        # Default to Gridline registration and Cartesian grid type
+        self._registration = 0
+        self._gtype = 0
+
+        # If the source file exists, get grid registration and grid type from the last
+        # two columns of the shortened summary information of grdinfo.
+        if (_source := self._obj.encoding.get("source")) and Path(_source).exists():
+            with contextlib.suppress(ValueError):
                 self._registration, self._gtype = map(
-                    int, grdinfo(self._source, per_column="n").split()[-2:]
+                    int, grdinfo(_source, per_column="n").split()[-2:]
                 )
-            except ValueError:
-                self._registration = 0  # Default to Gridline registration
-                self._gtype = 0  # Default to Cartesian grid type
-        else:
-            self._registration = 0  # Default to Gridline registration
-            self._gtype = 0  # Default to Cartesian grid type
-        del self._source
 
     @property
     def registration(self):

pygmt/helpers/utils.py

@@ -188,22 +188,27 @@ def _check_encoding(
 
 
 def data_kind(
-    data: Any = None, required: bool = True
+    data: Any, required: bool = True
 ) -> Literal[
     "arg", "file", "geojson", "grid", "image", "matrix", "stringio", "vectors"
 ]:
     r"""
     Check the kind of data that is provided to a module.
 
-    The ``data`` argument can be in any type, but only following types are supported:
-
-    - a string or a :class:`pathlib.PurePath` object or a sequence of them, representing
-      a file name or a list of file names
-    - a 2-D or 3-D :class:`xarray.DataArray` object
-    - a 2-D matrix
-    - None, bool, int or float type representing an optional arguments
-    - a geo-like Python object that implements ``__geo_interface__`` (e.g.,
-      geopandas.GeoDataFrame or shapely.geometry)
+    The argument passed to the ``data`` parameter can have any data type. The
+    following data kinds are recognized and returned as ``kind``:
+
+    - ``"arg"``: ``data`` is ``None`` and ``required=False``, or bool, int, float,
+      representing an optional argument, used for dealing with optional virtual files
+    - ``"file"``: a string or a :class:`pathlib.PurePath` object or a sequence of them,
+      representing one or more file names
+    - ``"geojson"``: a geo-like Python object that implements ``__geo_interface__``
+      (e.g., geopandas.GeoDataFrame or shapely.geometry)
+    - ``"grid"``: a :class:`xarray.DataArray` object that is not 3-D
+    - ``"image"``: a 3-D :class:`xarray.DataArray` object
+    - ``"stringio"``: a :class:`io.StringIO` object
+    - ``"matrix"``: anything else that is not ``None``
+    - ``"vectors"``: ``data`` is ``None`` and ``required=True``
 
     Parameters
     ----------
@@ -287,30 +292,31 @@ def data_kind(
     >>> data_kind(data=None)
     'vectors'
     """
-    kind: Literal[
-        "arg", "file", "geojson", "grid", "image", "matrix", "stringio", "vectors"
-    ]
-    if isinstance(data, str | pathlib.PurePath) or (
-        isinstance(data, list | tuple)
-        and all(isinstance(_file, str | pathlib.PurePath) for _file in data)
-    ):
-        # One or more files
-        kind = "file"
-    elif isinstance(data, bool | int | float) or (data is None and not required):
-        kind = "arg"
-    elif isinstance(data, io.StringIO):
-        kind = "stringio"
-    elif isinstance(data, xr.DataArray):
-        kind = "image" if len(data.dims) == 3 else "grid"
-    elif hasattr(data, "__geo_interface__"):
-        # geo-like Python object that implements ``__geo_interface__``
-        # (geopandas.GeoDataFrame or shapely.geometry)
-        kind = "geojson"
-    elif data is not None:
-        kind = "matrix"
-    else:
-        kind = "vectors"
-    return kind
+    match data:
+        case str() | pathlib.PurePath():  # One file.
+            kind = "file"
+        case list() | tuple() if all(
+            isinstance(_file, str | pathlib.PurePath) for _file in data
+        ):  # A list/tuple of files.
+            kind = "file"
+        case io.StringIO():
+            kind = "stringio"
+        case (bool() | int() | float()) | None if not required:
+            # An option argument, mainly for dealing with optional virtual files.
+            kind = "arg"
+        case xr.DataArray():
+            # An xarray.DataArray object, representing either a grid or an image.
+            kind = "image" if len(data.dims) == 3 else "grid"
+        case x if hasattr(x, "__geo_interface__"):
+            # Geo-like Python object that implements ``__geo_interface__`` (e.g.,
+            # geopandas.GeoDataFrame or shapely.geometry).
+            # Reference: https://gist.github.com/sgillies/2217756
+            kind = "geojson"
+        case x if x is not None:  # Any not-None is considered as a matrix.
+            kind = "matrix"
+        case _:  # Fall back to "vectors" if data is None and required=True.
+            kind = "vectors"
+    return kind  # type: ignore[return-value]
 
 
 def non_ascii_to_octal(

pygmt/tests/baseline/test_grdimage_grid_no_redunant_360.png.dvc

@@ -0,0 +1,5 @@
+outs:
+- md5: 6145622653eaedd2b4845400aa09ac75
+  size: 239431
+  hash: md5
+  path: test_grdimage_grid_no_redunant_360.png

pygmt/tests/test_grdimage.py

@@ -5,7 +5,9 @@
 import numpy as np
 import pytest
 import xarray as xr
+from packaging.version import Version
 from pygmt import Figure
+from pygmt.clib import __gmt_version__
 from pygmt.datasets import load_earth_relief
 from pygmt.exceptions import GMTInvalidInput
 from pygmt.helpers.testing import check_figures_equal
@@ -252,3 +254,41 @@ def test_grdimage_imgout_fails(grid):
         fig.grdimage(grid, img_out="out.png")
     with pytest.raises(GMTInvalidInput):
         fig.grdimage(grid, A="out.png")
+
+
+@pytest.mark.xfail(
+    condition=Version(__gmt_version__) <= Version("6.5.0"),
+    reason="Upstream bug fixed in https://github.com/GenericMappingTools/gmt/pull/8554",
+)
+@pytest.mark.mpl_image_compare()
+def test_grdimage_grid_no_redunant_360():
+    """
+    Test that global grids with and without redundant 360/0 longitude values work.
+
+    Test for https://github.com/GenericMappingTools/pygmt/issues/3331.
+    """
+    # Global grid [-180, 180, -90, 90] with redundant longitude at 180/-180
+    da1 = load_earth_relief(region=[-180, 180, -90, 90])
+    # Global grid [0, 360, -90, 90] with redundant longitude at 360/0
+    da2 = load_earth_relief(region=[0, 360, -90, 90])
+
+    # Global grid [-180, 179, -90, 90] without redundant longitude at 180/-180
+    da3 = da1[:, 0:360]
+    da3.gmt.registration, da3.gmt.gtype = 0, 1
+    assert da3.shape == (181, 360)
+    assert da3.lon.to_numpy().min() == -180.0
+    assert da3.lon.to_numpy().max() == 179.0
+
+    # Global grid [0, 359, -90, 90] without redundant longitude at 360/0
+    da4 = da2[:, 0:360]
+    da4.gmt.registration, da4.gmt.gtype = 0, 1
+    assert da4.shape == (181, 360)
+    assert da4.lon.to_numpy().min() == 0.0
+    assert da4.lon.to_numpy().max() == 359.0
+
+    fig = Figure()
+    kwdict = {"projection": "W120/10c", "region": "g", "frame": "+tlon=120"}
+    fig.grdimage(da3, **kwdict)
+    fig.shift_origin(xshift="w+2c")
+    fig.grdimage(da4, **kwdict)
+    return fig