Merge pull request #2623 from rcomer/bump-deps

MNT: bump minimum dependency versions

Author: greglucas

.github/workflows/ci-testing.yml

@@ -17,11 +17,11 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: ['3.10', '3.11', '3.12', '3.13']
+        python-version: ['3.11', '3.12', '3.13']
         use-network: [true]
         include:
           - os: ubuntu-latest
-            python-version: '3.11'
+            python-version: '3.13'
             use-network: false
 
     steps:
@@ -37,17 +37,17 @@ jobs:
 
       - name: Minimum packages
         if: |
-          matrix.python-version == '3.10' && matrix.os == 'ubuntu-latest' &&
+          matrix.python-version == '3.11' && matrix.os == 'ubuntu-latest' &&
           (github.event_name == 'push' || github.event_name == 'pull_request')
         id: minimum-packages
         run: |
-          pip install cython==0.29.28 matplotlib==3.6 numpy==1.23 owslib==0.27 pyproj==3.3.1 scipy==1.9 shapely==2.0 pyshp==2.3.1
+          pip install cython==3.0 matplotlib==3.8 numpy==1.26 owslib==0.29 pyproj==3.6 scipy==1.11 shapely==2.0 pyshp==2.3.1
 
       - name: Coverage packages
         id: coverage
         # only want the coverage to be run on the latest ubuntu and for code changes i.e. push and pr
         if: |
-          matrix.python-version == '3.12' && matrix.os == 'ubuntu-latest' &&
+          matrix.python-version == '3.13' && matrix.os == 'ubuntu-latest' &&
           (github.event_name == 'push' || github.event_name == 'pull_request')
         run: |
           echo "CYTHON_COVERAGE=1" >> $GITHUB_ENV

INSTALL

@@ -59,20 +59,20 @@ To use it::
 
 Further information about the required dependencies can be found here:
 
-**Python** 3.10 or later (https://www.python.org/)
+**Python** 3.11 or later (https://www.python.org/)
     Python 2 support was removed in v0.19.
 
-**Matplotlib** 3.6 or later (https://matplotlib.org/)
+**Matplotlib** 3.8 or later (https://matplotlib.org/)
     Python package for 2D plotting. Python package required for any
     graphical capabilities.
 
 **Shapely** 2.0 or later (https://github.com/shapely/shapely)
     Python package for the manipulation and analysis of planar geometric objects.
 
-**pyshp** 2.3 or later (https://pypi.python.org/pypi/pyshp)
+**pyshp** 2.3.1 or later (https://pypi.python.org/pypi/pyshp)
     Pure Python read/write support for ESRI Shapefile format.
 
-**pyproj** 3.3.1 or later (https://github.com/pyproj4/pyproj/)
+**pyproj** 3.6 or later (https://github.com/pyproj4/pyproj/)
     Python interface to PROJ (cartographic projections and coordinate transformations library).
 
 Optional Dependencies
@@ -90,10 +90,10 @@ the optional OWS libraries.
     A fast kd-tree implementation that is used for faster warping
     of images than SciPy.
 
-**SciPy** 1.9 or later (https://www.scipy.org/)
+**SciPy** 1.11 or later (https://www.scipy.org/)
     A Python package for scientific computing.
 
-**OWSLib** 0.27 or later (https://pypi.python.org/pypi/OWSLib)
+**OWSLib** 0.29 or later (https://pypi.python.org/pypi/OWSLib)
      A Python package for client programming with the Open Geospatial
      Consortium (OGC) web service, and which gives access to Cartopy ogc
      clients.

environment.yml

@@ -8,24 +8,24 @@ name: cartopy-dev
 channels:
   - conda-forge
 dependencies:
-  - cython>=0.29.28
-  - numpy>=1.23
+  - cython>=3.0
+  - numpy>=1.26
   - shapely>=2.0
-  - pyshp>=2.3
-  - pyproj>=3.3.1
-  - packaging>=21
+  - pyshp>=2.3.1
+  - pyproj>=3.6.0
   # The testing label has the proper version of freetype included
   - conda-forge/label/testing::matplotlib-base>=3.6
 
   # OWS
-  - owslib>=0.27
+  - owslib>=0.29
   - pillow>=9.1
   # Plotting
-  - scipy>=1.9
+  - scipy>=1.11
   # Testing
   - pytest
   - pytest-mpl
   - pytest-xdist
+  - packaging>=21
   # Documentation
   - pydata-sphinx-theme
   - sphinx

lib/cartopy/mpl/__init__.py

@@ -2,11 +2,3 @@
 #
 # This file is part of Cartopy and is released under the BSD 3-clause license.
 # See LICENSE in the root of the repository for full licensing details.
-
-import matplotlib
-import packaging.version
-
-
-_MPL_VERSION = packaging.version.parse(matplotlib.__version__)
-_MPL_37 = _MPL_VERSION.release[:2] >= (3, 7)
-_MPL_38 = _MPL_VERSION.release[:2] >= (3, 8)

lib/cartopy/mpl/contour.py

@@ -4,10 +4,6 @@
 # See LICENSE in the root of the repository for full licensing details.
 
 from matplotlib.contour import QuadContourSet
-import matplotlib.path as mpath
-import numpy as np
-
-from cartopy.mpl import _MPL_38
 
 
 class GeoContourSet(QuadContourSet):
@@ -20,91 +16,26 @@ class GeoContourSet(QuadContourSet):
     # fiddling with instance.__class__.
 
     def clabel(self, *args, **kwargs):
-        if not _MPL_38:
-            # nb: contour labelling does not work very well for filled
-            # contours - it is recommended to only label line contours.
-            # This is especially true when inline=True.
-
-            # This wrapper exist because mpl does not properly transform
-            # paths. Instead it simply assumes one path represents one polygon
-            # (not necessarily the case), and it assumes that
-            # transform(path.verts) is equivalent to transform_path(path).
-            # Unfortunately there is no way to easily correct this error,
-            # so we are forced to pre-transform the ContourSet's paths from
-            # the source coordinate system to the axes' projection.
-            # The existing mpl code then has a much simpler job of handling
-            # pre-projected paths (which can now effectively be transformed
-            # naively).
-
-            for col in self.collections:
-                # Snaffle the collection's path list. We will change the
-                # list in-place (as the contour label code does in mpl).
-                paths = col.get_paths()
-
-                # Define the transform that will take us from collection
-                # coordinates through to axes projection coordinates.
-                data_t = self.axes.transData
-                col_to_data = col.get_transform() - data_t
-
-                # Now that we have the transform, project all of this
-                # collection's paths.
-                new_paths = [col_to_data.transform_path(path)
-                             for path in paths]
-                new_paths = [path for path in new_paths
-                             if path.vertices.size >= 1]
-
-                # The collection will now be referenced in axes projection
-                # coordinates.
-                col.set_transform(data_t)
-
-                # Clear the now incorrectly referenced paths.
-                del paths[:]
-
-                for path in new_paths:
-                    if path.vertices.size == 0:
-                        # Don't persist empty paths. Let's get rid of them.
-                        continue
-
-                    # Split the path if it has multiple MOVETO statements.
-                    codes = np.array(
-                        path.codes if path.codes is not None else [0])
-                    moveto = codes == mpath.Path.MOVETO
-                    if moveto.sum() <= 1:
-                        # This is only one path, so add it to the collection.
-                        paths.append(path)
-                    else:
-                        # The first MOVETO doesn't need cutting-out.
-                        moveto[0] = False
-                        split_locs = np.flatnonzero(moveto)
-
-                        split_verts = np.split(path.vertices, split_locs)
-                        split_codes = np.split(path.codes, split_locs)
-
-                        for verts, codes in zip(split_verts, split_codes):
-                            # Add this path to the collection's list of paths.
-                            paths.append(mpath.Path(verts, codes))
-
-        else:
-            # Where contour paths exist at the edge of the globe, sometimes a
-            # complete path in data space will become multiple paths when
-            # transformed into axes or screen space.  Matplotlib's contour
-            # labelling does not account for this so we need to give it the
-            # pre-transformed paths to work with.
-
-            # Define the transform that will take us from collection
-            # coordinates through to axes projection coordinates.
-            data_t = self.axes.transData
-            col_to_data = self.get_transform() - data_t
-
-            # Now that we have the transform, project all of this
-            # collection's paths.
-            paths = self.get_paths()
-            new_paths = [col_to_data.transform_path(path) for path in paths]
-            self.set_paths(new_paths)
-
-            # The collection will now be referenced in axes projection
-            # coordinates.
-            self.set_transform(data_t)
+        # Where contour paths exist at the edge of the globe, sometimes a
+        # complete path in data space will become multiple paths when
+        # transformed into axes or screen space.  Matplotlib's contour
+        # labelling does not account for this so we need to give it the
+        # pre-transformed paths to work with.
+
+        # Define the transform that will take us from collection
+        # coordinates through to axes projection coordinates.
+        data_t = self.axes.transData
+        col_to_data = self.get_transform() - data_t
+
+        # Now that we have the transform, project all of this
+        # collection's paths.
+        paths = self.get_paths()
+        new_paths = [col_to_data.transform_path(path) for path in paths]
+        self.set_paths(new_paths)
+
+        # The collection will now be referenced in axes projection
+        # coordinates.
+        self.set_transform(data_t)
 
         # Now that we have prepared the collection paths, call on
         # through to the underlying implementation.

lib/cartopy/mpl/feature_artist.py

@@ -17,7 +17,6 @@
 import numpy as np
 
 import cartopy.feature as cfeature
-from cartopy.mpl import _MPL_38
 import cartopy.mpl.path as cpath
 
 
@@ -145,11 +144,6 @@ def set_facecolor(self, c):
         else:
             super().set_facecolor(c)
 
-    if not _MPL_38:
-        # set_paths does not yet exist on Collection.
-        def set_paths(self, paths):
-            self._paths = paths
-
     def _get_geoms_paths(self):
         ax = self.axes
         feature_crs = self._feature.crs

lib/cartopy/mpl/geoaxes.py

@@ -38,7 +38,6 @@
 from cartopy import config
 import cartopy.crs as ccrs
 import cartopy.feature
-from cartopy.mpl import _MPL_38
 import cartopy.mpl.contour
 import cartopy.mpl.feature_artist as feature_artist
 import cartopy.mpl.geocollection
@@ -1592,21 +1591,12 @@ def contour(self, *args, **kwargs):
         """
         result = super().contour(*args, **kwargs)
 
-        if not _MPL_38:
-            # We need to compute the dataLim correctly for contours.
-            bboxes = [col.get_datalim(self.transData)
-                      for col in result.collections
-                      if col.get_paths()]
-            if bboxes:
-                extent = mtransforms.Bbox.union(bboxes)
-                self.update_datalim(extent.get_points())
-        else:
-            # We need to compute the dataLim correctly for contours and set the
-            # artist's sticky edges to match.
-            datalim = result.get_datalim(self.transData)
-            self.update_datalim(datalim)
-            result.sticky_edges.x[:] = datalim.xmin, datalim.xmax
-            result.sticky_edges.y[:] = datalim.ymin, datalim.ymax
+        # We need to compute the dataLim correctly for contours and set the
+        # artist's sticky edges to match.
+        datalim = result.get_datalim(self.transData)
+        self.update_datalim(datalim)
+        result.sticky_edges.x[:] = datalim.xmin, datalim.xmax
+        result.sticky_edges.y[:] = datalim.ymin, datalim.ymax
 
         self.autoscale_view()
 
@@ -1638,21 +1628,12 @@ def contourf(self, *args, **kwargs):
         """
         result = super().contourf(*args, **kwargs)
 
-        if not _MPL_38:
-            # We need to compute the dataLim correctly for contours.
-            bboxes = [col.get_datalim(self.transData)
-                      for col in result.collections
-                      if col.get_paths()]
-            if bboxes:
-                extent = mtransforms.Bbox.union(bboxes)
-                self.update_datalim(extent.get_points())
-        else:
-            # We need to compute the dataLim correctly for contours and set the
-            # artist's sticky edges to match.
-            datalim = result.get_datalim(self.transData)
-            self.update_datalim(datalim)
-            result.sticky_edges.x[:] = datalim.xmin, datalim.xmax
-            result.sticky_edges.y[:] = datalim.ymin, datalim.ymax
+        # We need to compute the dataLim correctly for contours and set the
+        # artist's sticky edges to match.
+        datalim = result.get_datalim(self.transData)
+        self.update_datalim(datalim)
+        result.sticky_edges.x[:] = datalim.xmin, datalim.xmax
+        result.sticky_edges.y[:] = datalim.ymin, datalim.ymax
 
         self.autoscale_view()
 
@@ -1936,36 +1917,19 @@ def _wrap_quadmesh(self, collection, **kwargs):
         vmax = kwargs.pop('vmax', None)
         norm = kwargs.pop('norm', None)
         cmap = kwargs.pop('cmap', None)
+
         # Plot all of the wrapped cells.
         # `pcolor` only draws polygons where the data is not
         # masked, so this will only draw a limited subset of
         # polygons that were actually wrapped.
-
-        if not _MPL_38:
-            # We will add the original data mask in later to
-            # make sure that set_array can work in future
-            # calls on the proper sized array inputs.
-            # NOTE: we don't use C.data here because C.data could
-            #       contain nan's which would be masked in the
-            #       pcolor routines, which we don't want. We will
-            #       fill in the proper data later with set_array()
-            #       calls.
-            pcolor_zeros = np.ma.array(np.zeros(C.shape), mask=pcolor_mask)
-            pcolor_col = self.pcolor(coords[..., 0], coords[..., 1],
-                                     pcolor_zeros, zorder=zorder,
-                                     **kwargs)
-
-            # The pcolor_col is now possibly shorter than the
-            # actual collection, so grab the masked cells
-            pcolor_col.set_array(pcolor_data[mask].ravel())
-        else:
-            pcolor_col = self.pcolor(coords[..., 0], coords[..., 1],
-                                     pcolor_data, zorder=zorder,
-                                     **kwargs)
-            # Currently pcolor_col.get_array() will return a compressed array
-            # and warn unless we explicitly set the 2D array.  This should be
-            # unnecessary with future matplotlib versions.
-            pcolor_col.set_array(pcolor_data)
+        pcolor_col = self.pcolor(coords[..., 0], coords[..., 1],
+                                 pcolor_data, zorder=zorder,
+                                 **kwargs)
+
+        # In matplotlib v3.8 and v3.9 pcolor_col.get_array() will return a
+        # compressed array and warn unless we explicitly set the 2D array.
+        # This can be removed when we support only matplotlib v3.10+.
+        pcolor_col.set_array(pcolor_data)
 
         pcolor_col.set_cmap(cmap)
         pcolor_col.set_norm(norm)