shapely 2.1.0rc1__tar.gz → 2.1.2__tar.gz

{shapely-2.1.0rc1 → shapely-2.1.2}/CHANGES.txt

@@ -1,88 +1,37 @@
 Changes
 =======
 
-2.1.0 (unreleased)
+2.1.2 (2025-09-24)
 ------------------
 
-API changes:
+Wheels are available for Python 3.14 (and still include GEOS 3.13.1).
 
-- Equality of geometries (``geom1 == geom2``) now considers NaN coordinate
-  values in the same location to be equal (#1775). It is recommended however to
-  ensure geometries don't have NaN values in the first place, for which you can
-  now use the ``handle_nan`` parameter in construction functions.
+
+2.1.1 (2025-05-19)
+------------------
 
 Bug fixes:
 
-- Prevent crash when serializing a number > 1e100 to WKT with GEOS < 3.13. (#1907)
-- Ensure ``plot_polygon`` does not color the interiors of polygons (#1933).
-- Fixes GeoJSON serialization of empty points (#2118)
-- Fixes `__geo_interface__` handling of empty points (#2120)
-- Fixes ``GeometryCollection()`` constructor accepting an array of geometries (#2017).
+- 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).
 
-Improvements:
 
-- Add a ``handle_nan`` parameter to ``shapely.points()``,
-  ``shapely.linestrings()`` and ``shapely.linearrings()`` to allow, skip, or
-  error on nonfinite (NaN / Inf) coordinates. The default behaviour (allow) is
-  backwards compatible (#1594, #1811).
-- Add an ``interleaved`` parameter to ``shapely.transform()`` allowing a transposed call
-  signature in the ``transformation`` function.
-- The ``include_z`` in ``shapely.transform()`` now also allows ``None``, which
-  lets it automatically detect the dimensionality of each input geometry.
-- Add an ``include_m`` keyword in ``to_ragged_array`` and ``get_coordinates`` (#2234, #2235)
-- Add parameters ``method`` and ``keep_collapsed`` to ``shapely.make_valid()`` (#1941)
-- The ``voronoi_polygons`` now accepts the ``ordered`` keyword, optionally forcing the
-  order of polygons within the GeometryCollection to follow the order of input
-  coordinates. Requires at least GEOS 3.12. (#1968)
-- Add option on ``invalid="fix"`` to ``from_wkb`` and ``from_wkt`` (#2094)
-- Add a ``normalize`` keyword to ``equals_exact`` (#1231)
-- Handle ``Feature`` type in ``shapely.geometry.shape`` (#1815)
-- Add support to split polygons by multilinestrings (#2206)
-- Add an ``m`` attribute on the Point class and an ``has_m`` attribute on the base Geometry class.
-
-New functions:
-
-- Add ``disjoint_subset_union`` and ``disjoint_subset_union_all`` as an optimized
-  version of union and union_all, assuming inputs can be divided into subsets that do
-  not intersect. Requires at least GEOS 3.12.
-- Add function ``minimum_clearance_line`` (#2106)
-- Add function ``maximum_inscribed_circle`` (#1307)
-- Add function ``orient_polygons`` (#2147)
-- Add function ``constrained_delaunay_triangles`` (#1685)
-- Add function ``coverage_simplify`` to allow topological simplification of polygonal
-  coverages (#1969)
-- Add function ``coverage_is_valid`` and ``coverage_invalid_edges`` to validate
-  an array of geometries as valid topological coverage (#2156)
-- Add function ``equals_identical`` (#1760)
-- Add function ``has_m`` (#2008)
-- Add function ``get_m`` (#2019)
-
-Breaking changes in GEOS 3.12:
-
-- ``oriented_envelope`` / ``minimum_rotated_rectangle`` changed its implementation
-  in GEOS 3.12. Be aware that results will change when updating GEOS. Coincidentally
-  the implementation is similar to the shapely 1.x approach. (#1885)
-- ``get_coordinate_dimension`` / ``has_z`` now considers geometries three dimensional if
-  they have a NaN z coordinate. (#1885)
-- ``voronoi_polygons`` changed its output from a LINESTRING to a MULTILINESTRING in case
-  ``only_edges=True``. (#1885)
-- The WKT representation of a MULTIPOINT changed from for example "MULTIPOINT (0 0, 1 1)"
-  to "MULTIPOINT ((0 0), (1 1))". (#1885)
+2.1.0 (2025-04-03)
+------------------
 
-Deprecations:
+Shapely 2.1.0 is a feature release with various new functions,
+improvements and bug fixes. Highlights include initial support for geometries
+with M or ZM values, functionality for coverage validation and
+simplification, and a set of new top-level functions.
 
-- The ``shapely.geos`` module is deprecated. All GEOS-version related attributes are
-  available directly from the top-level ``shapely`` namespace as well (already since
-  shapely 2.0) (#2145).
-- The ``shapely.vectorized`` module is deprecated. The two functions (``contains and
-  ``touches``) can be replaced by the top-level vectorized functions ``contains_xy``
-  and ``intersects_xy`` (#1630).
+Shapely supports Python >= 3.10, and binary wheels on PyPI include GEOS 3.13.1
+and are now also provided for musllinux (Alpine) x86_64 platforms.
 
-Packaging:
+For a full changelog, see
+https://shapely.readthedocs.io/en/latest/release/2.x.html#version-2-1-0
 
-- Require GEOS >= 3.9, NumPy >= 1.21, and Python >= 3.10 (#1802, #1885, #2124)
-- Binary wheels are now built for musllinux (Alpine) x86_64 platforms (#1996).
-- Upgraded the GEOS version in the binary wheel distributions to 3.13.1.
 
 2.0.7 (2025-01-30)
 ------------------

{shapely-2.1.0rc1 → shapely-2.1.2}/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.0.7"
-date-released: "2025-01-30"
+version: "2.1.2"
+date-released: "2025-09-24"
 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.0rc1 → shapely-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: shapely
-Version: 2.1.0rc1
+Version: 2.1.2
 Summary: Manipulation and analysis of geometric objects
 Author: Sean Gillies
 Maintainer: Shapely contributors
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: GIS
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
@@ -35,6 +36,7 @@ Requires-Dist: matplotlib; extra == "docs"
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-book-theme; extra == "docs"
 Requires-Dist: sphinx-remove-toctrees; extra == "docs"
+Dynamic: license-file
 
 =======
 Shapely

{shapely-2.1.0rc1 → shapely-2.1.2}/docs/coverage.rst

@@ -9,3 +9,5 @@ Coverage operations
 {% for function in get_module_functions("_coverage") %}
    {{ function }}
 {% endfor %}
+   coverage_union
+   coverage_union_all

{shapely-2.1.0rc1 → shapely-2.1.2}/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.0rc1 → shapely-2.1.2}/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.0rc1 → shapely-2.1.2}/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.0rc1 → shapely-2.1.2}/pyproject.toml

@@ -35,6 +35,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: GIS",
 ]
 requires-python = ">=3.10"
@@ -74,7 +75,7 @@ skip = ["pp*", "*_i686", "*_ppc64le", "*_s390x"]
 build-verbosity = 1
 test-requires = "pytest"
 test-command = "pytest --pyargs shapely.tests"
-free-threaded-support = true
+enable = ["cpython-freethreading"]
 
 [tool.coverage.run]
 source = ["shapely"]

{shapely-2.1.0rc1 → shapely-2.1.2}/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.0rc1 → shapely-2.1.2}/shapely/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-15T15:43:48+0100",
+ "date": "2025-09-24T15:22:48+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "7cd599893ea3b478b662189449514a239da5751d",
- "version": "2.1.0rc1"
+ "full-revisionid": "5fb639d1056888d135fe56bfaf750c9648addeec",
+ "version": "2.1.2"
 }
 '''  # END VERSION_JSON