Update dependencies

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -10,7 +10,7 @@ repos:
       - id: mixed-line-ending
       - id: check-case-conflict
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.1 # must match uv.lock
+    rev: v0.13.0 # must match uv.lock
     hooks:
       - id: ruff-check
       - id: ruff-format

pyproject.toml

@@ -83,6 +83,7 @@ strict = true
 warn_unused_ignores = true
 disallow_untyped_defs = false
 disallow_incomplete_defs = false
+enable_error_code = "deprecated"
 
 [tool.pyright]
 # Project settings

tests/geopandas/test_io.py

@@ -40,7 +40,11 @@ def test_read_file(tmp_path: Path) -> None:
 def test_infer_schema() -> None:
     schema = infer_schema(GDF)
     heterogeneous_schema = infer_schema(gpd.GeoDataFrame({"x": [1, 2], "geometry": [P, LS]}))
-    check(assert_type(schema, _Schema), _Schema, dtype=str)
+    check(
+        assert_type(schema, _Schema),
+        _Schema,  # pyright: ignore[reportGeneralTypeIssues]
+        dtype=str,
+    )
     check(assert_type(schema["geometry"], str | list[str]), str)
     check(assert_type(heterogeneous_schema["geometry"], str | list[str]), list, dtype=str)
     check(assert_type(schema["properties"], OrderedDict[str, str]), OrderedDict, dtype=str)

tests/shapely/test_coordinates.py

@@ -16,42 +16,31 @@
 
 
 def test_transform() -> None:
-    # TODO: remove astype(np.float64) when https://github.com/numpy/numpy/issues/28071 is fixed
     check(assert_type(shapely.transform(P, lambda x: x), Point), Point)
-    check(assert_type(shapely.transform(P, lambda x: (x + 1.0).astype(np.float64)), Point), Point)
+    check(assert_type(shapely.transform(P, lambda x: x + 1.0), Point), Point)
     check(assert_type(shapely.transform(None, lambda x: x), None), NoneType)
     check(
-        assert_type(
-            shapely.transform(shapely.from_wkt(P.wkt), lambda x: (x + 1.0).astype(np.float64)),
-            BaseGeometry,
-        ),
+        assert_type(shapely.transform(shapely.from_wkt(P.wkt), lambda x: x + 1.0), BaseGeometry),
         Point,
     )
 
     def transformer(coords: ArrayLike) -> NDArray[np.float64]:
-        return (np.asarray(coords) + 1).astype(np.float64)
+        return np.asarray(coords) + 1
 
     check(assert_type(shapely.transform(P, transformer), Point), Point)
 
     check(
-        assert_type(
-            shapely.transform([P], lambda x: (x + 1.0).astype(np.float64)), NDArray[np.object_]
-        ),
+        assert_type(shapely.transform([P], lambda x: x + 1.0), NDArray[np.object_]),
         np.ndarray,
         dtype=Point,
     )
     check(
-        assert_type(
-            shapely.transform([None], lambda x: (x + 1.0).astype(np.float64)), NDArray[np.object_]
-        ),
+        assert_type(shapely.transform([None], lambda x: x + 1.0), NDArray[np.object_]),
         np.ndarray,
         dtype=NoneType,
     )
     check(
-        assert_type(
-            shapely.transform((P, None), lambda x: (x + 1.0).astype(np.float64)),
-            NDArray[np.object_],
-        ),
+        assert_type(shapely.transform((P, None), lambda x: x + 1.0), NDArray[np.object_]),
         np.ndarray,
         dtype=Point,
     )
@@ -88,7 +77,7 @@ def test_get_coordinates() -> None:
     )
     coords, idx = with_index
     check(coords, np.ndarray, dtype=float)
-    check(idx, np.ndarray, dtype=np.integer)
+    check(idx, np.ndarray, dtype=np.int64)
     check(
         assert_type(
             shapely.get_coordinates([P, None], return_index=True),

tests/shapely/test_geometry.py

@@ -483,71 +483,69 @@ def __geo_interface__(self) -> dict[str, object]:
 
 def test_generic_getset() -> None:
     # type_id
-    check(assert_type(shapely.get_type_id(P), int), np.integer)
-    check(assert_type(shapely.get_type_id(None), int), np.integer)
-    check(assert_type(shapely.get_type_id([P]), NDArray[np.int64]), np.ndarray, dtype=np.integer)
-    check(assert_type(shapely.get_type_id([None]), NDArray[np.int64]), np.ndarray, dtype=np.integer)
+    check(assert_type(shapely.get_type_id(P), np.int32), np.int32)
+    check(assert_type(shapely.get_type_id(None), np.int32), np.int32)
+    check(assert_type(shapely.get_type_id([P]), NDArray[np.int64]), np.ndarray, dtype=np.int32)
+    check(assert_type(shapely.get_type_id([None]), NDArray[np.int64]), np.ndarray, dtype=np.int32)
     check(
-        assert_type(shapely.get_type_id((P, None)), NDArray[np.int64]), np.ndarray, dtype=np.integer
+        assert_type(shapely.get_type_id((P, None)), NDArray[np.int64]), np.ndarray, dtype=np.int32
     )
 
     # dimensions
-    check(assert_type(shapely.get_dimensions(P), int), np.integer)
-    check(assert_type(shapely.get_dimensions(None), int), np.integer)
-    check(assert_type(shapely.get_dimensions([P]), NDArray[np.int64]), np.ndarray, dtype=np.integer)
+    check(assert_type(shapely.get_dimensions(P), np.int32), np.int32)
+    check(assert_type(shapely.get_dimensions(None), np.int32), np.int32)
+    check(assert_type(shapely.get_dimensions([P]), NDArray[np.int64]), np.ndarray, dtype=np.int32)
     check(
-        assert_type(shapely.get_dimensions([None]), NDArray[np.int64]), np.ndarray, dtype=np.integer
+        assert_type(shapely.get_dimensions([None]), NDArray[np.int64]), np.ndarray, dtype=np.int32
     )
     check(
         assert_type(shapely.get_dimensions((P, None)), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
 
     # coordinate_dimension
-    check(assert_type(shapely.get_coordinate_dimension(P), int), np.integer)
-    check(assert_type(shapely.get_coordinate_dimension(None), int), np.integer)
+    check(assert_type(shapely.get_coordinate_dimension(P), np.int32), np.int32)
+    check(assert_type(shapely.get_coordinate_dimension(None), np.int32), np.int32)
     check(
         assert_type(shapely.get_coordinate_dimension([P]), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
     check(
         assert_type(shapely.get_coordinate_dimension([None]), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
     check(
         assert_type(shapely.get_coordinate_dimension((P, None)), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
 
     # num_coordinates
-    check(assert_type(shapely.get_num_coordinates(P), int), np.integer)
-    check(assert_type(shapely.get_num_coordinates(None), int), np.integer)
+    check(assert_type(shapely.get_num_coordinates(P), np.int32), np.int32)
+    check(assert_type(shapely.get_num_coordinates(None), np.int32), np.int32)
     check(
-        assert_type(shapely.get_num_coordinates([P]), NDArray[np.int64]),
-        np.ndarray,
-        dtype=np.integer,
+        assert_type(shapely.get_num_coordinates([P]), NDArray[np.int64]), np.ndarray, dtype=np.int32
     )
     check(
         assert_type(shapely.get_num_coordinates([None]), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
     check(
         assert_type(shapely.get_num_coordinates((P, None)), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
 
     # srid
-    check(assert_type(shapely.get_srid(P), int), np.integer)
-    check(assert_type(shapely.get_srid(None), int), np.integer)
-    check(assert_type(shapely.get_srid([P]), NDArray[np.int64]), np.ndarray, dtype=np.integer)
-    check(assert_type(shapely.get_srid([None]), NDArray[np.int64]), np.ndarray, dtype=np.integer)
-    check(assert_type(shapely.get_srid((P, None)), NDArray[np.int64]), np.ndarray, dtype=np.integer)
+    check(assert_type(shapely.get_srid(P), np.int32), np.int32)
+    check(assert_type(shapely.get_srid(None), np.int32), np.int32)
+    check(assert_type(shapely.get_srid([P]), NDArray[np.int64]), np.ndarray, dtype=np.int32)
+    check(assert_type(shapely.get_srid([None]), NDArray[np.int64]), np.ndarray, dtype=np.int32)
+    check(assert_type(shapely.get_srid((P, None)), NDArray[np.int64]), np.ndarray, dtype=np.int32)
 
     check(assert_type(shapely.set_srid(P, 20), Point), Point)
     check(assert_type(shapely.set_srid(None, 20), None), NoneType)
@@ -560,8 +558,8 @@ def test_generic_getset() -> None:
     )
 
     # precision
-    check(assert_type(shapely.get_precision(None), float), float)
-    check(assert_type(shapely.get_precision(P), float), float)
+    check(assert_type(shapely.get_precision(None), np.float64), np.float64)
+    check(assert_type(shapely.get_precision(P), np.float64), np.float64)
     check(assert_type(shapely.get_precision([P]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(shapely.get_precision([None]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(
@@ -615,23 +613,23 @@ def test_generic_getset() -> None:
 
 
 def test_point_getset() -> None:
-    check(assert_type(shapely.get_x(P), float), float)
-    check(assert_type(shapely.get_x(LS), float), float)
-    check(assert_type(shapely.get_x(None), float), float)
+    check(assert_type(shapely.get_x(P), np.float64), np.float64)
+    check(assert_type(shapely.get_x(LS), np.float64), np.float64)
+    check(assert_type(shapely.get_x(None), np.float64), np.float64)
     check(assert_type(shapely.get_x([P]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(shapely.get_x([None]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(shapely.get_x((P, None)), NDArray[np.float64]), np.ndarray, dtype=float)
 
-    check(assert_type(shapely.get_y(P), float), float)
-    check(assert_type(shapely.get_y(LS), float), float)
-    check(assert_type(shapely.get_y(None), float), float)
+    check(assert_type(shapely.get_y(P), np.float64), np.float64)
+    check(assert_type(shapely.get_y(LS), np.float64), np.float64)
+    check(assert_type(shapely.get_y(None), np.float64), np.float64)
     check(assert_type(shapely.get_y([P]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(shapely.get_y([None]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(shapely.get_y((P, None)), NDArray[np.float64]), np.ndarray, dtype=float)
 
-    check(assert_type(shapely.get_z(P), float), float)
-    check(assert_type(shapely.get_z(LS), float), float)
-    check(assert_type(shapely.get_z(None), float), float)
+    check(assert_type(shapely.get_z(P), np.float64), np.float64)
+    check(assert_type(shapely.get_z(LS), np.float64), np.float64)
+    check(assert_type(shapely.get_z(None), np.float64), np.float64)
     check(assert_type(shapely.get_z([P]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(shapely.get_z([None]), NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(shapely.get_z((P, None)), NDArray[np.float64]), np.ndarray, dtype=float)
@@ -658,17 +656,17 @@ def test_linestring_getset() -> None:
     check(assert_type(shapely.get_point(LS, [0]), NDArray[np.object_]), np.ndarray, dtype=Point)
     check(assert_type(shapely.get_point([LS], [0]), NDArray[np.object_]), np.ndarray, dtype=Point)
 
-    check(assert_type(shapely.get_num_points(LS), int), np.integer)
-    check(assert_type(shapely.get_num_points(P), int), np.integer)
-    check(assert_type(shapely.get_num_points(None), int), np.integer)
-    check(assert_type(shapely.get_num_points([P]), NDArray[np.int64]), np.ndarray, dtype=np.integer)
+    check(assert_type(shapely.get_num_points(LS), np.int32), np.int32)
+    check(assert_type(shapely.get_num_points(P), np.int32), np.int32)
+    check(assert_type(shapely.get_num_points(None), np.int32), np.int32)
+    check(assert_type(shapely.get_num_points([P]), NDArray[np.int64]), np.ndarray, dtype=np.int32)
     check(
-        assert_type(shapely.get_num_points([None]), NDArray[np.int64]), np.ndarray, dtype=np.integer
+        assert_type(shapely.get_num_points([None]), NDArray[np.int64]), np.ndarray, dtype=np.int32
     )
     check(
         assert_type(shapely.get_num_points((P, None)), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
 
 
@@ -735,23 +733,23 @@ def test_polygon_getset() -> None:
         dtype=LinearRing,
     )
 
-    check(assert_type(shapely.get_num_interior_rings(PO), int), np.integer)
-    check(assert_type(shapely.get_num_interior_rings(P), int), np.integer)
-    check(assert_type(shapely.get_num_interior_rings(None), int), np.integer)
+    check(assert_type(shapely.get_num_interior_rings(PO), np.int32), np.int32)
+    check(assert_type(shapely.get_num_interior_rings(P), np.int32), np.int32)
+    check(assert_type(shapely.get_num_interior_rings(None), np.int32), np.int32)
     check(
         assert_type(shapely.get_num_interior_rings([P]), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
     check(
         assert_type(shapely.get_num_interior_rings([None]), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
     check(
         assert_type(shapely.get_num_interior_rings((P, None)), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
 
 
@@ -787,23 +785,21 @@ def test_collection_getset() -> None:
         assert_type(shapely.get_geometry([MP], [0]), NDArray[np.object_]), np.ndarray, dtype=Point
     )
 
-    check(assert_type(shapely.get_num_geometries(MP), int), np.integer)
-    check(assert_type(shapely.get_num_geometries(P), int), np.integer)
-    check(assert_type(shapely.get_num_geometries(None), int), np.integer)
+    check(assert_type(shapely.get_num_geometries(MP), np.int32), np.int32)
+    check(assert_type(shapely.get_num_geometries(P), np.int32), np.int32)
+    check(assert_type(shapely.get_num_geometries(None), np.int32), np.int32)
     check(
-        assert_type(shapely.get_num_geometries([P]), NDArray[np.int64]),
-        np.ndarray,
-        dtype=np.integer,
+        assert_type(shapely.get_num_geometries([P]), NDArray[np.int64]), np.ndarray, dtype=np.int32
     )
     check(
         assert_type(shapely.get_num_geometries([None]), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
     check(
         assert_type(shapely.get_num_geometries((P, None)), NDArray[np.int64]),
         np.ndarray,
-        dtype=np.integer,
+        dtype=np.int32,
     )
 
     check(assert_type(shapely.get_parts(P), NDArray[np.object_]), np.ndarray, dtype=Point)
@@ -825,7 +821,7 @@ def test_collection_getset() -> None:
         dtype=np.ndarray,
     )
     check(assert_type(parts_with_index[0], NDArray[np.object_]), np.ndarray, dtype=BaseGeometry)
-    check(assert_type(parts_with_index[1], NDArray[np.int64]), np.ndarray, dtype=np.integer)
+    check(assert_type(parts_with_index[1], NDArray[np.int64]), np.ndarray, dtype=np.int64)
     check(
         assert_type(
             shapely.get_parts(None, return_index=True),
@@ -871,7 +867,7 @@ def test_collection_getset() -> None:
         dtype=np.ndarray,
     )
     check(assert_type(parts_with_index[0], NDArray[np.object_]), np.ndarray, dtype=LinearRing)
-    check(assert_type(parts_with_index[1], NDArray[np.int64]), np.ndarray, dtype=np.integer)
+    check(assert_type(parts_with_index[1], NDArray[np.int64]), np.ndarray, dtype=np.int64)
     check(
         assert_type(
             shapely.get_rings(None, return_index=True),

tests/shapely/test_io.py

@@ -102,7 +102,7 @@ def test_ragged_array() -> None:
     check(assert_type(ra[0], GeometryType), GeometryType)
     check(assert_type(ra[1], NDArray[np.float64]), np.ndarray, dtype=float)
     check(assert_type(ra[2], tuple[NDArray[np.int64], ...]), tuple, dtype=np.ndarray)
-    check(assert_type(ra[2][0], NDArray[np.int64]), np.ndarray, dtype=np.integer)
+    check(assert_type(ra[2][0], NDArray[np.int64]), np.ndarray, dtype=np.int32)
     check(
         assert_type(
             shapely.to_ragged_array([PO], include_z=True),

tests/shapely/test_linear.py

@@ -53,12 +53,14 @@ def test_line_interpolate_point() -> None:
 
 
 def test_line_locate_point() -> None:
-    check(assert_type(shapely.line_locate_point(LS, P), float), float)
-    check(assert_type(shapely.line_locate_point(MLS, P), float), float)
-    check(assert_type(shapely.line_locate_point(GeometryCollection(MLS), P), float), float)
-    check(assert_type(shapely.line_locate_point(None, P), float), float)
-    check(assert_type(shapely.line_locate_point(LS, None), float), float)
-    check(assert_type(shapely.line_locate_point(None, None), float), float)
+    check(assert_type(shapely.line_locate_point(LS, P), np.float64), np.float64)
+    check(assert_type(shapely.line_locate_point(MLS, P), np.float64), np.float64)
+    check(
+        assert_type(shapely.line_locate_point(GeometryCollection(MLS), P), np.float64), np.float64
+    )
+    check(assert_type(shapely.line_locate_point(None, P), np.float64), np.float64)
+    check(assert_type(shapely.line_locate_point(LS, None), np.float64), np.float64)
+    check(assert_type(shapely.line_locate_point(None, None), np.float64), np.float64)
     check(
         assert_type(shapely.line_locate_point([MLS, LS], P), NDArray[np.float64]),
         np.ndarray,
@@ -74,7 +76,7 @@ def test_line_locate_point() -> None:
         np.ndarray,
         dtype=float,
     )
-    check(assert_type(shapely.line_locate_point(LS, P, normalized=True), float), float)
+    check(assert_type(shapely.line_locate_point(LS, P, normalized=True), np.float64), np.float64)
     check(
         assert_type(shapely.line_locate_point([MLS, LS], P, normalized=True), NDArray[np.float64]),
         np.ndarray,