shapely 2.1.0__tar.gz → 2.1.1__tar.gz

{shapely-2.1.0 → shapely-2.1.1}/CHANGES.txt

@@ -1,6 +1,17 @@
 Changes
 =======
 
+2.1.1 (2025-05-19)
+------------------
+
+Bug fixes:
+
+- Fix performance degradation calling shapely functions (caused by deprecation
+  of certain positional arguments) (#2283).
+- Fix crash caused by `from_ragged_array()` (#2291).
+- Fix compilation error building with recent LLVM toolchain (#2293).
+
+
 2.1.0 (2025-04-03)
 ------------------
 

{shapely-2.1.0 → shapely-2.1.1}/CITATION.cff

@@ -2,8 +2,8 @@ cff-version: 1.2.0
 message: "Please cite this software using these metadata."
 type: software
 title: Shapely
-version: "2.1.0"
-date-released: "2025-04-03"
+version: "2.1.1"
+date-released: "2025-05-19"
 doi: 10.5281/zenodo.5597138
 abstract: "Manipulation and analysis of geometric objects in the Cartesian plane."
 repository-artifact: https://pypi.org/project/Shapely

{shapely-2.1.0 → shapely-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shapely
-Version: 2.1.0
+Version: 2.1.1
 Summary: Manipulation and analysis of geometric objects
 Author: Sean Gillies
 Maintainer: Shapely contributors

{shapely-2.1.0 → shapely-2.1.1}/docs/geometry.rst

@@ -84,7 +84,7 @@ Therefore, geometries are equal if and only if their WKB representations are equ
   >>> point_1 = Point(5.2, 52.1)
   >>> point_2 = Point(1, 1)
   >>> point_3 = Point(5.2, 52.1)
-  >>> {point_1, point_2, point_3}
+  >>> {point_1, point_2, point_3}  # doctest: +SKIP
   {<POINT (1 1)>, <POINT (5.2 52.1)>}
 
 .. warning:: Due to limitations of WKB, linearrings will equal linestrings if they contain the exact same points.
@@ -113,9 +113,9 @@ The most convenient is to use ``.wkb_hex`` and ``.wkt`` properties.
   >>> from shapely import Point, to_wkb, to_wkt, to_geojson
   >>> pt = Point(-169.910918, -18.997564)
   >>> pt.wkb_hex
-  0101000000CF6A813D263D65C0BDAAB35A60FF32C0
+  '0101000000CF6A813D263D65C0BDAAB35A60FF32C0'
   >>> pt.wkt
-  POINT (-169.910918 -18.997564)
+  'POINT (-169.910918 -18.997564)'
 
 More output options can be found using using :func:`~shapely.to_wkb`,
 :func:`~shapely.to_wkt`, and :func:`~shapely.to_geojson` functions.
@@ -123,9 +123,9 @@ More output options can be found using using :func:`~shapely.to_wkb`,
 .. code:: python
 
   >>> to_wkb(pt, hex=True, byte_order=0)
-  0000000001C0653D263D816ACFC032FF605AB3AABD
+  '0000000001C0653D263D816ACFC032FF605AB3AABD'
   >>> to_wkt(pt, rounding_precision=3)
-  POINT (-169.911 -18.998)
+  'POINT (-169.911 -18.998)'
   >>> print(to_geojson(pt, indent=2))
   {
     "type": "Point",
@@ -158,21 +158,35 @@ Semantic for format specification
 
 Format types ``'f'`` and ``'F'`` are to use a fixed-point notation, which is
 activated by setting GEOS' trim option off.
-The upper case variant converts ``nan`` to ``NAN`` and ``inf`` to ``INF``.
 
-Format types ``'g'`` and ``'G'`` are to use a "general format",
+Format types ``'g'`` (default) and ``'G'`` are to use a "general format",
 where unnecessary digits are trimmed. This notation is activated by setting
-GEOS' trim option on. The upper case variant is similar to
-``'F'``, and may also display an upper-case ``"E"`` if scientific notation
-is required. Note that this representation may be different for GEOS 3.10.0
-and later, which does not use scientific notation.
+GEOS' trim option on. This option sometimes enables
+:ref:`scientific-formatting`.
 
-For numeric outputs ``'f'`` and ``'g'``, the precision is optional, and if not
+For numeric outputs ``[fFgG]``, the precision is optional, and if not
 specified, rounding precision will be disabled showing full precision.
 
 Format types ``'x'`` and ``'X'`` show a hex-encoded string representation of
-WKB or Well-Known Binary, with the case of the output matched the
-case of the format type character.
+WKB or Well-Known Binary.
+
+The upper case letter variant converts all non-numeric values to uppercase,
+e.g. ``nan`` to ``NAN``, or ``e`` to ``E``.
+
+.. _scientific-formatting:
+
+Scientific formatting
+---------------------
+
+WKT outputs may sometimes use scientific formatting, depending on the GEOS
+version, coordinate value and WKT writer options. GEOS versions 3.10 to 3.12
+never use scientific formatting (only showing positional), while older and
+newer versions may use scientific formatting for large and small coordinate
+values (e.g. ``POINT (1.234e+18 1.234e-11)``).
+
+Scientific formatting can always be disabled by setting ``trim=False`` for
+:func:`~shapely.to_wkt` or other WKT writer methods,
+which sets the WKT writer to use fixed-precision number formatting.
 
 .. _canonical-form:
 

{shapely-2.1.0 → shapely-2.1.1}/docs/manual.rst

@@ -1285,34 +1285,7 @@ and that copies of these are collected into a list
   >>> features = [c, a, d, b, c]
 
 that we'd prefer to have ordered as ``[d, c, c, b, a]`` in reverse containment
-order. As explained in the Python `Sorting HowTo`_, we can define a key
-function that operates on each list element and returns a value for comparison.
-Our key function will be a wrapper class that implements ``__lt__()`` using
-Shapely's binary :meth:`~object.within` predicate.
-
-.. code-block:: python
-
-  >>> class Within:
-  ...     def __init__(self, o):
-  ...         self.o = o
-  ...     def __lt__(self, other):
-  ...         return self.o.within(other.o)
-
-As the howto says, the `less than` comparison is guaranteed to be used in
-sorting. That's what we'll rely on to spatially sort. Trying it out on features
-`d` and `c`, we see that it works.
-
-.. code-block:: pycon
-
-  >>> Within(d) < Within(c)
-  False
-
-It also works on the list of features, producing the order we want.
-
-.. code-block:: pycon
-
-  >>> [d, c, c, b, a] == sorted(features, key=Within, reverse=True)
-  True
+order.
 
 DE-9IM Relationships
 --------------------

{shapely-2.1.0 → shapely-2.1.1}/docs/migration.rst

@@ -5,9 +5,9 @@ Migrating to Shapely 1.8 / 2.0
 ==============================
 
 Shapely 1.8.0 is a transitional version introducing several warnings in
-preparation of the upcoming changes in 2.0.0.
+transition to 2.0.0.
 
-Shapely 2.0.0 will be a major release with a refactor of the internals with
+Shapely 2.0.0 was a major release with a refactor of the internals with
 considerable performance improvements (based on the developments in the
 `PyGEOS <https://github.com/pygeos/pygeos>`__ package), along with several
 breaking changes.
@@ -33,13 +33,13 @@ can change their coordinates in-place. Illustrative code::
     >>> print(line)
     LINESTRING (0 0, 2 2)
 
-    >>> line.coords = [(0, 0), (10, 0), (10, 10)]
-    >>> print(line)
+    >>> line.coords = [(0, 0), (10, 0), (10, 10)]  # doctest: +SKIP
+    >>> print(line)  # doctest: +SKIP
     LINESTRING (0 0, 10 0, 10 10)
 
 In Shapely 1.8, this will start raising a warning::
 
-    >>> line.coords = [(0, 0), (10, 0), (10, 10)]
+    >>> line.coords = [(0, 0), (10, 0), (10, 10)]  # doctest: +SKIP
     ShapelyDeprecationWarning: Setting the 'coords' to mutate a Geometry
     in place is deprecated, and will not be possible any more in Shapely 2.0
 
@@ -56,15 +56,16 @@ Setting custom attributes
 -------------------------
 
 Another consequence of the geometry objects becoming immutable is that
-assigning custom attributes, which currently works, will no longer be possible.
+assigning custom attributes, which previously worked, will no longer be
+possible.
 
-Currently you can do::
+Previously, custom attributes could have ben added::
 
-    >>> line.name = "my_geometry"
-    >>> line.name
+    >>> line.name = "my_geometry"  # doctest: +SKIP
+    >>> line.name  # doctest: +SKIP
     'my_geometry'
 
-In Shapely 1.8, this will start raising a warning, and will raise an
+In Shapely 1.8, this will raise a warning, and will raise an
 AttributeError in Shapely 2.0.
 
 **How do I update my code?** There is no direct alternative for adding custom
@@ -85,18 +86,18 @@ Some examples of this with Shapely 1.x:
 
     >>> from shapely.geometry import Point, MultiPoint
     >>> mp = MultiPoint([(1, 1), (2, 2), (3, 3)])
-    >>> print(mp)
+    >>> print(mp)  # doctest: +SKIP
     MULTIPOINT (1 1, 2 2, 3 3)
-    >>> for part in mp:
-    ...     print(part)
+    >>> for part in mp:  # doctest: +SKIP
+    ...     print(part)  # doctest: +SKIP
     POINT (1 1)
     POINT (2 2)
     POINT (3 3)
-    >>> print(mp[1])
+    >>> print(mp[1])  # doctest: +SKIP
     POINT (2 2)
-    >>> len(mp)
+    >>> len(mp)  # doctest: +SKIP
     3
-    >>> list(mp)
+    >>> list(mp)  # doctest: +SKIP
     [<shapely.geometry.point.Point at 0x7f2e0912bf10>,
      <shapely.geometry.point.Point at 0x7f2e09fed820>,
      <shapely.geometry.point.Point at 0x7f2e09fed4c0>]
@@ -104,8 +105,8 @@ Some examples of this with Shapely 1.x:
 Starting with Shapely 1.8, all the examples above will start raising a
 deprecation warning. For example:
 
-    >>> for part in mp:
-    ...     print(part)
+    >>> for part in mp:  # doctest: +SKIP
+    ...     print(part)  # doctest: +SKIP
     ShapelyDeprecationWarning: Iteration over multi-part geometries is deprecated
     and will be removed in Shapely 2.0. Use the `geoms` property to access the
     constituent parts of a multi-part geometry.
@@ -129,7 +130,7 @@ The examples above can be updated to::
     POINT (2 2)
     >>> len(mp.geoms)
     3
-    >>> list(mp.geoms)
+    >>> list(mp.geoms)  # doctest: +SKIP
     [<shapely.geometry.point.Point at 0x7f2e0912bf10>,
      <shapely.geometry.point.Point at 0x7f2e09fed820>,
      <shapely.geometry.point.Point at 0x7f2e09fed4c0>]
@@ -152,7 +153,7 @@ A small example::
 
     >>> line = LineString([(0, 0), (1, 1), (2, 2)])
     >>> import numpy as np
-    >>> np.asarray(line)
+    >>> np.asarray(line)  # doctest: +SKIP
     array([[0., 0.],
            [1., 1.],
            [2., 2.]])
@@ -160,9 +161,9 @@ A small example::
 In addition, there are also the explicit ``array_interface()`` method and
 ``ctypes`` attribute to get access to the coordinates as array data:
 
-    >>> line.ctypes
+    >>> line.ctypes  # doctest: +SKIP
     <shapely.geometry.linestring.c_double_Array_6 at 0x7f75261eb740>
-    >>> line.array_interface()
+    >>> line.array_interface()  # doctest: +SKIP
     {'version': 3,
      'typestr': '<f8',
      'data': <shapely.geometry.linestring.c_double_Array_6 at 0x7f752664ae40>,
@@ -177,7 +178,7 @@ removed from those geometry classes, and limited to the ``coords``.
 Starting with Shapely 1.8, converting a geometry object to a NumPy array
 directly will start raising a warning::
 
-    >>> np.asarray(line)
+    >>> np.asarray(line)  # doctest: +SKIP
     ShapelyDeprecationWarning: The array interface is deprecated and will no longer
     work in Shapely 2.0. Convert the '.coords' to a NumPy array instead.
     array([[0., 0.],
@@ -209,7 +210,7 @@ as follows::
 
     >>> from shapely.geometry import Point
     >>> arr = np.array([Point(0, 0), Point(1, 1), Point(2, 2)])
-    >>> arr
+    >>> arr  # doctest: +SKIP
     array([<shapely.geometry.point.Point object at 0x7fb798407cd0>,
            <shapely.geometry.point.Point object at 0x7fb7982831c0>,
            <shapely.geometry.point.Point object at 0x7fb798283b80>],
@@ -300,7 +301,7 @@ creation methods. A small example for an empty Polygon geometry:
     >>> g1 = Polygon()
     >>> type(g1)
     <class 'shapely.geometry.polygon.Polygon'>
-    >>> g1.wkt
+    >>> g1.wkt  # doctest: +SKIP
     GEOMETRYCOLLECTION EMPTY
 
     # Converting from WKT gives a correct empty polygon
@@ -309,7 +310,7 @@ creation methods. A small example for an empty Polygon geometry:
     >>> type(g2)
     <class 'shapely.geometry.polygon.Polygon'>
     >>> g2.wkt
-    POLYGON EMPTY
+    'POLYGON EMPTY'
 
 Shapely 1.8 does not yet change this inconsistent behaviour, but starting
 with Shapely 2.0, the different methods will always consistently give an

{shapely-2.1.0 → shapely-2.1.1}/shapely/_geometry_helpers.pyx

@@ -284,7 +284,7 @@ def get_parts(object[:] array, bint extract_rings=0):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef void _deallocate_arr(void* handle, np.intp_t[:] arr, Py_ssize_t last_geom_i) noexcept nogil:
+cdef void _deallocate_arr(GEOSContextHandle_t handle, np.intp_t[:] arr, Py_ssize_t last_geom_i) noexcept nogil:
     """Deallocate a temporary geometry array to prevent memory leaks"""
     cdef Py_ssize_t i = 0
     cdef GEOSGeometry *g
@@ -421,7 +421,7 @@ def collections_1d(object geometries, object indices, int geometry_type = 7, obj
                 coll = GEOSGeom_createPolygon_r(
                     geos_handle,
                     <GEOSGeometry*> temp_geoms_view[0],
-                    NULL if coll_size <= 1 else <GEOSGeometry**> &temp_geoms_view[1],
+                    <GEOSGeometry**> NULL if coll_size <= 1 else <GEOSGeometry**> &temp_geoms_view[1],
                     coll_size - 1
                 )
             else:  # Polygon, empty
@@ -454,7 +454,7 @@ def _from_ragged_array_multi_linear(
     MultiLineString (geometry_type 5): linear_type is a LineString (1)
     """
     cdef:
-        Py_ssize_t n_geoms
+        Py_ssize_t n_total_coords, n_rings, n_geoms
         Py_ssize_t i, k
         Py_ssize_t i1, i2, k1, k2
         Py_ssize_t n_coords, linear_idx
@@ -463,12 +463,26 @@ def _from_ragged_array_multi_linear(
         GEOSGeometry *linear = NULL
         GEOSGeometry *geom = NULL
 
+    n_total_coords = coordinates.shape[0]
+    n_rings = offsets1.shape[0] - 1
     n_geoms = offsets2.shape[0] - 1
 
+    if offsets2[n_geoms] > n_rings:
+        raise ValueError(
+            f"Number of rings indicated by the geometry offsets ({offsets2[n_geoms]}) "
+            f"larger than indicated by the shape of the linear offsets array ({n_rings})"
+        )
+
+    if offsets1[n_rings] > n_total_coords:
+        raise ValueError(
+            f"Number of coordinates indicated by the linear offsets ({offsets1[n_rings]}) "
+            f"larger than the shape of the coordinates array ({n_total_coords})"
+        )
+
     # A temporary array for the geometries that will be given to CreatePolygon/Collection.
-    # For simplicity, we use n_geoms instead of calculating
-    # the max needed size (trading performance for a bit more memory usage)
-    temp_linear = np.empty(shape=(n_geoms, ), dtype=np.intp)
+    # For simplicity, we use n_rings instead of calculating the max needed size
+    # as max(diff(offsets2)) (trading performance for a bit more memory usage)
+    temp_linear = np.empty(shape=(n_rings, ), dtype=np.intp)
     cdef np.intp_t[:] temp_linear_view = temp_linear
     # A temporary array for resulting geometries
     temp_geoms = np.empty(shape=(n_geoms, ), dtype=np.intp)
@@ -570,7 +584,7 @@ def _from_ragged_array_multipolygon(
     Create MultiPolygons from coordinate and offset arrays.
     """
     cdef:
-        Py_ssize_t n_geoms
+        Py_ssize_t n_total_coords, n_rings, n_parts, n_geoms
         Py_ssize_t i, j, k
         Py_ssize_t i1, i2, j1, j2, k1, k2
         Py_ssize_t n_coords, rings_idx, parts_idx
@@ -580,14 +594,35 @@ def _from_ragged_array_multipolygon(
         GEOSGeometry *part = NULL
         GEOSGeometry *geom = NULL
 
+    n_total_coords = coordinates.shape[0]
+    n_rings = offsets1.shape[0] - 1
+    n_parts = offsets2.shape[0] - 1
     n_geoms = offsets3.shape[0] - 1
 
+    if offsets3[n_geoms] > n_parts:
+        raise ValueError(
+            f"Number of geometry parts indicated by the geometry offsets ({offsets3[n_geoms]}) "
+            f"larger than indicated by the shape of the part offsets array ({n_parts})"
+        )
+
+    if offsets2[n_parts] > n_rings:
+        raise ValueError(
+            f"Number of rings indicated by the part offsets ({offsets2[n_parts]}) "
+            f"larger than indicated by the shape of the linear offsets array ({n_rings})"
+        )
+
+    if offsets1[n_rings] > n_total_coords:
+        raise ValueError(
+            f"Number of coordinates indicated by the linear offsets ({offsets1[n_rings]}) "
+            f"larger than the shape of the coordinates array ({n_total_coords})"
+        )
+
     # A temporary array for the geometries that will be given to CreatePolygon
-    # and CreateCollection. For simplicity, we use n_geoms instead of calculating
-    # the max needed size (trading performance for a bit more memory usage)
-    temp_rings = np.empty(shape=(n_geoms, ), dtype=np.intp)
+    # and CreateCollection. For simplicity, we use n_rings/n_parts instead of
+    # calculating the max needed size (trading performance for a bit more memory usage)
+    temp_rings = np.empty(shape=(n_rings, ), dtype=np.intp)
     cdef np.intp_t[:] temp_rings_view = temp_rings
-    temp_parts = np.empty(shape=(n_geoms, ), dtype=np.intp)
+    temp_parts = np.empty(shape=(n_parts, ), dtype=np.intp)
     cdef np.intp_t[:] temp_parts_view = temp_parts
     # A temporary array for resulting geometries
     temp_geoms = np.empty(shape=(n_geoms, ), dtype=np.intp)

{shapely-2.1.0 → shapely-2.1.1}/shapely/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-04-03T10:55:05+0200",
+ "date": "2025-05-19T12:40:46+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "4940c6405ac9ef2d77c9e9990954b68294c3c399",
- "version": "2.1.0"
+ "full-revisionid": "b49155ea7eaec698a0357fb9bc1147533b566916",
+ "version": "2.1.1"
 }
 '''  # END VERSION_JSON
 

{shapely-2.1.0 → shapely-2.1.1}/shapely/decorators.py

@@ -1,9 +1,10 @@
 """Decorators for Shapely functions."""
 
-import inspect
 import os
 import warnings
-from functools import wraps
+from collections.abc import Callable, Iterable
+from functools import lru_cache, wraps
+from inspect import unwrap
 
 import numpy as np
 
@@ -92,41 +93,90 @@ def multithreading_enabled(func):
     return wrapped
 
 
-def deprecate_positional(should_be_kwargs, category=DeprecationWarning):
-    """Show warning if positional arguments are used that should be keyword."""
+def deprecate_positional(
+    should_be_kwargs: Iterable[str],
+    category: type[Warning] = DeprecationWarning,
+):
+    """Show warning if positional arguments are used that should be keyword.
+
+    Parameters
+    ----------
+    should_be_kwargs : Iterable[str]
+        Names of parameters that should be passed as keyword arguments.
+    category : type[Warning], optional (default: DeprecationWarning)
+        Warning category to use for deprecation warnings.
+
+    Returns
+    -------
+    callable
+        Decorator function that adds positional argument deprecation warnings.
+
+    Examples
+    --------
+    >>> from shapely.decorators import deprecate_positional
+    >>> @deprecate_positional(['b', 'c'])
+    ... def example(a, b, c=None):
+    ...     return a, b, c
+    ...
+    >>> example(1, 2)  # doctest: +SKIP
+    DeprecationWarning: positional argument `b` for `example` is deprecated. ...
+    (1, 2, None)
+    >>> example(1, b=2)  # No warnings
+    (1, 2, None)
+    """
+
+    def decorator(func: Callable):
+        code = unwrap(func).__code__
+
+        # positional parameters are the first co_argcount names
+        pos_names = code.co_varnames[: code.co_argcount]
+        # build a name -> index map
+        name_to_idx = {name: idx for idx, name in enumerate(pos_names)}
+        # pick out only those names we care about
+        deprecate_positions = [
+            (name_to_idx[name], name)
+            for name in should_be_kwargs
+            if name in name_to_idx
+        ]
+
+        # early exit if there are no deprecated positional args
+        if not deprecate_positions:
+            return func
+
+        # earliest position where a warning could occur
+        warn_from = min(deprecate_positions)[0]
+
+        @lru_cache(10)
+        def make_msg(n_args: int):
+            used = [name for idx, name in deprecate_positions if idx < n_args]
+
+            if len(used) == 1:
+                args_txt = f"`{used[0]}`"
+                plr = ""
+                isare = "is"
+            else:
+                plr = "s"
+                isare = "are"
+                if len(used) == 2:
+                    args_txt = " and ".join(f"`{u}`" for u in used)
+                else:
+                    args_txt = ", ".join(f"`{u}`" for u in used[:-1])
+                    args_txt += f", and `{used[-1]}`"
+
+            return (
+                f"positional argument{plr} {args_txt} for `{func.__name__}` "
+                f"{isare} deprecated. Please use keyword argument{plr} instead."
+            )
 
-    def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
-            # call the function first, to make sure the signature matches
-            ret_value = func(*args, **kwargs)
-
-            # check signature to see which positional args were used
-            sig = inspect.signature(func)
-            args_bind = sig.bind_partial(*args)
-            warn_args = [
-                f"`{arg}`"
-                for arg in args_bind.arguments.keys()
-                if arg in should_be_kwargs
-            ]
-            if warn_args:
-                if len(warn_args) == 1:
-                    plr = ""
-                    isare = "is"
-                    args = warn_args[0]
-                else:
-                    plr = "s"
-                    isare = "are"
-                    if len(warn_args) < 3:
-                        args = " and ".join(warn_args)
-                    else:
-                        args = ", ".join(warn_args[:-1]) + ", and " + warn_args[-1]
-                msg = (
-                    f"positional argument{plr} {args} for `{func.__name__}` "
-                    f"{isare} deprecated.  Please use keyword argument{plr} instead."
-                )
-                warnings.warn(msg, category=category, stacklevel=2)
-            return ret_value
+            result = func(*args, **kwargs)
+
+            n = len(args)
+            if n > warn_from:
+                warnings.warn(make_msg(n), category=category, stacklevel=2)
+
+            return result
 
         return wrapper
 

{shapely-2.1.0 → shapely-2.1.1}/shapely/io.py

@@ -56,7 +56,8 @@ def to_wkt(
         The rounding precision when writing the WKT string. Set to a value of
         -1 to indicate the full precision.
     trim : bool, default True
-        If True, trim unnecessary decimals (trailing zeros).
+        If True, trim unnecessary decimals (trailing zeros). If False,
+        use fixed-precision number formatting.
     output_dimension : int, default None
         The output dimension for the WKT string. Supported values are 2, 3 and
         4 for GEOS 3.12+. Default None will automatically choose 3 or 4,

{shapely-2.1.0 → shapely-2.1.1}/shapely/tests/legacy/test_polylabel.py

@@ -48,7 +48,10 @@ class PolylabelTestCase(unittest.TestCase):
             ]
         )
         label = polylabel(polygon)
-        if shapely.geos_version >= (3, 12, 0):
+        if shapely.geos_version >= (3, 14, 0):
+            # https://github.com/libgeos/geos/issues/1265
+            assert label.coords[:] == [(32.722025, -117.195155)]
+        elif shapely.geos_version >= (3, 12, 0):
             # recent GEOS corrects for this
             assert label.coords[:] == [(32.722025, -117.201875)]
         else:

{shapely-2.1.0 → shapely-2.1.1}/shapely/tests/test_constructive.py

@@ -1184,7 +1184,7 @@ def test_maximum_inscribed_circle_all_types(geometry):
             GEOSException,
             match=(
                 "Argument must be Polygonal or LinearRing|"  # GEOS < 3.10.4
-                "Input geometry must be a Polygon or MultiPolygon|"
+                "must be a Polygon or MultiPolygon|"
                 "Operation not supported by GeometryCollection"
             ),
         ):
@@ -1193,7 +1193,7 @@ def test_maximum_inscribed_circle_all_types(geometry):
 
     if geometry.is_empty:
         with pytest.raises(
-            GEOSException, match="Empty input geometry is not supported"
+            GEOSException, match="Empty input(?: geometry)? is not supported"
         ):
             shapely.maximum_inscribed_circle(geometry)
         return
@@ -1227,13 +1227,15 @@ def test_maximum_inscribed_circle_empty():
         GEOSException,
         match=(
             "Argument must be Polygonal or LinearRing|"  # GEOS < 3.10.4
-            "Input geometry must be a Polygon or MultiPolygon"
+            "must be a Polygon or MultiPolygon"
         ),
     ):
         shapely.maximum_inscribed_circle(geometry)
 
     geometry = shapely.from_wkt("POLYGON EMPTY")
-    with pytest.raises(GEOSException, match="Empty input geometry is not supported"):
+    with pytest.raises(
+        GEOSException, match="Empty input(?: geometry)? is not supported"
+    ):
         shapely.maximum_inscribed_circle(geometry)