update for pydantic 2.0

Author: vincentsarago

.pre-commit-config.yaml

@@ -23,11 +23,11 @@ repos:
         args: ["--fix"]
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.991
+    rev: v1.4.1
     hooks:
       - id: mypy
         language_version: python
         # No reason to run if only tests have changed. They intentionally break typing.
         exclude: tests/.*
         additional_dependencies:
-        - pydantic~=1.0
+        - pydantic~=2.0

CHANGELOG.md

@@ -6,9 +6,31 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 Note: Minor version `0.X.0` update might break the API, It's recommanded to pin geojson-pydantic to minor version: `geojson-pydantic>=0.6,<0.7`
 
+## [unreleased]
+
+### Added
+
+* more tests for `GeometryCollection` warnings
+
+### changed
+
+* update pydantic requirement to `~=2.0`
+
+* raise `ValueError` in `geomtries.parse_geometry_obj` instead of `ValidationError`
+
+    ```python
+    # before
+    parse_geometry_obj({"type": "This type", "obviously": "doesn't exist"})
+    >> ValidationError
+
+    # now
+    parse_geometry_obj({"type": "This type", "obviously": "doesn't exist"})
+    >> ValueError("Unknown type: This type")
+    ```
+
 ## [0.6.3] - 2023-07-02
 
-* limit pydantic requirement to `~=1.0``
+* limit pydantic requirement to `~=1.0`
 
 ## [0.6.2] - 2023-05-16
 

README.md

@@ -146,7 +146,7 @@ from typing import Optional
 MyPointFeatureModel = Feature[Optional[Point], Dict]
 
 assert MyPointFeatureModel(type="Feature", geometry=None, properties={}).geometry is None
-assert MyPointFeatureModel(type="Feature", geometry=Point(coordinates=(0,0)), properties={}).geometry is not None
+assert MyPointFeatureModel(type="Feature", geometry=Point(type="Point", coordinates=(0,0)), properties={}).geometry is not None
 ```
 
 And now with constrained properties
@@ -157,7 +157,7 @@ from pydantic import BaseModel, constr
 
 # Define a Feature model with Geometry as `Point` and Properties as a constrained Model
 class MyProps(BaseModel):
-    name: constr(regex=r'^(drew|vincent)$')
+    name: constr(pattern=r'^(drew|vincent)$')
 
 MyPointFeatureModel = Feature[Point, MyProps]
 

geojson_pydantic/features.py

@@ -2,8 +2,7 @@
 
 from typing import Any, Dict, Generic, Iterator, List, Literal, Optional, TypeVar, Union
 
-from pydantic import BaseModel, Field, StrictInt, StrictStr, validator
-from pydantic.generics import GenericModel
+from pydantic import BaseModel, Field, StrictInt, StrictStr, field_validator
 
 from geojson_pydantic.geo_interface import GeoInterfaceMixin
 from geojson_pydantic.geometries import Geometry, GeometryCollection
@@ -13,7 +12,7 @@
 Geom = TypeVar("Geom", bound=Union[Geometry, GeometryCollection])
 
 
-class Feature(GenericModel, Generic[Geom, Props], GeoInterfaceMixin):
+class Feature(BaseModel, Generic[Geom, Props], GeoInterfaceMixin):
     """Feature Model"""
 
     type: Literal["Feature"]
@@ -22,9 +21,9 @@ class Feature(GenericModel, Generic[Geom, Props], GeoInterfaceMixin):
     id: Optional[Union[StrictInt, StrictStr]] = None
     bbox: Optional[BBox] = None
 
-    _validate_bbox = validator("bbox", allow_reuse=True)(validate_bbox)
+    _validate_bbox = field_validator("bbox")(validate_bbox)
 
-    @validator("geometry", pre=True, always=True)
+    @field_validator("geometry", mode="before")
     def set_geometry(cls, geometry: Any) -> Any:
         """set geometry from geo interface or input"""
         if hasattr(geometry, "__geo_interface__"):
@@ -33,7 +32,7 @@ def set_geometry(cls, geometry: Any) -> Any:
         return geometry
 
 
-class FeatureCollection(GenericModel, Generic[Geom, Props], GeoInterfaceMixin):
+class FeatureCollection(BaseModel, Generic[Geom, Props], GeoInterfaceMixin):
     """FeatureCollection Model"""
 
     type: Literal["FeatureCollection"]
@@ -52,4 +51,4 @@ def __getitem__(self, index: int) -> Feature:
         """get feature at a given index"""
         return self.features[index]
 
-    _validate_bbox = validator("bbox", allow_reuse=True)(validate_bbox)
+    _validate_bbox = field_validator("bbox")(validate_bbox)

geojson_pydantic/geometries.py

@@ -5,8 +5,7 @@
 import warnings
 from typing import Any, Iterator, List, Literal, Optional, Union
 
-from pydantic import BaseModel, Field, ValidationError, validator
-from pydantic.error_wrappers import ErrorWrapper
+from pydantic import BaseModel, Field, field_validator
 from typing_extensions import Annotated
 
 from geojson_pydantic.geo_interface import GeoInterfaceMixin
@@ -108,7 +107,7 @@ def wkt(self) -> str:
 
         return wkt
 
-    _validate_bbox = validator("bbox", allow_reuse=True)(validate_bbox)
+    _validate_bbox = field_validator("bbox")(validate_bbox)
 
 
 class Point(_GeometryBase):
@@ -185,7 +184,7 @@ def __wkt_coordinates__(self, coordinates: Any, force_z: bool) -> str:
         """return WKT coordinates."""
         return _lines_wtk_coordinates(coordinates, force_z)
 
-    @validator("coordinates")
+    @field_validator("coordinates")
     def check_closure(cls, coordinates: List) -> List:
         """Validate that Polygon is closed (first and last coordinate are the same)."""
         if any(ring[-1] != ring[0] for ring in coordinates):
@@ -238,7 +237,7 @@ def has_z(self) -> bool:
         """Checks if any coordinates have a Z value."""
         return any(_lines_has_z(polygon) for polygon in self.coordinates)
 
-    @validator("coordinates")
+    @field_validator("coordinates")
     def check_closure(cls, coordinates: List) -> List:
         """Validate that Polygon is closed (first and last coordinate are the same)."""
         if any(ring[-1] != ring[0] for polygon in coordinates for ring in polygon):
@@ -290,23 +289,26 @@ def wkt(self) -> str:
         z = " Z " if "Z" in geometries else " "
         return f"{self.type.upper()}{z}{geometries}"
 
-    _validate_bbox = validator("bbox", allow_reuse=True)(validate_bbox)
+    _validate_bbox = field_validator("bbox")(validate_bbox)
 
-    @validator("geometries")
+    @field_validator("geometries")
     def check_geometries(cls, geometries: List) -> List:
         """Add warnings for conditions the spec does not explicitly forbid."""
         if len(geometries) == 1:
             warnings.warn(
                 "GeometryCollection should not be used for single geometries."
             )
+
         if any(geom.type == "GeometryCollection" for geom in geometries):
             warnings.warn(
                 "GeometryCollection should not be used for nested GeometryCollections."
             )
+
         if len({geom.type for geom in geometries}) == 1:
             warnings.warn(
                 "GeometryCollection should not be used for homogeneous collections."
             )
+
         return geometries
 
 
@@ -316,25 +318,24 @@ def parse_geometry_obj(obj: Any) -> Geometry:
     reads the `"type"` field and returns the correct pydantic Geometry model.
     """
     if "type" not in obj:
-        raise ValidationError(
-            errors=[
-                ErrorWrapper(ValueError("Missing 'type' field in geometry"), loc="type")
-            ],
-            model=_GeometryBase,
-        )
+        raise ValueError("Missing 'type' field in geometry")
+
     if obj["type"] == "Point":
         return Point.parse_obj(obj)
+
     elif obj["type"] == "MultiPoint":
         return MultiPoint.parse_obj(obj)
+
     elif obj["type"] == "LineString":
         return LineString.parse_obj(obj)
+
     elif obj["type"] == "MultiLineString":
         return MultiLineString.parse_obj(obj)
+
     elif obj["type"] == "Polygon":
         return Polygon.parse_obj(obj)
+
     elif obj["type"] == "MultiPolygon":
         return MultiPolygon.parse_obj(obj)
-    raise ValidationError(
-        errors=[ErrorWrapper(ValueError("Unknown type"), loc="type")],
-        model=_GeometryBase,
-    )
+
+    raise ValueError(f"Unknown type: {obj['type']}")

geojson_pydantic/types.py

@@ -48,8 +48,8 @@ def validate_bbox(bbox: Optional[BBox]) -> Optional[BBox]:
     LineStringCoords = List[Position]
     LinearRing = List[Position]
 else:
-    LineStringCoords = conlist(Position, min_items=2)
-    LinearRing = conlist(Position, min_items=4)
+    LineStringCoords = conlist(Position, min_length=2)
+    LinearRing = conlist(Position, min_length=4)
 
 MultiPointCoords = List[Position]
 MultiLineStringCoords = List[LineStringCoords]

pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dynamic = ["version"]
-dependencies = ["pydantic~=1.0"]
+dependencies = ["pydantic~=2.0"]
 
 [project.optional-dependencies]
 test = ["pytest", "pytest-cov", "shapely"]

tests/test_geometries.py

@@ -428,11 +428,13 @@ def test_parse_geometry_obj_multi_polygon():
 
 
 def test_parse_geometry_obj_invalid_type():
-    with pytest.raises(ValidationError):
+    with pytest.raises(ValueError):
         parse_geometry_obj({"type": "This type", "obviously": "doesn't exist"})
-    with pytest.raises(ValidationError):
+
+    with pytest.raises(ValueError):
         parse_geometry_obj({"type": "", "obviously": "doesn't exist"})
-    with pytest.raises(ValidationError):
+
+    with pytest.raises(ValueError):
         parse_geometry_obj({})
 
 
@@ -502,6 +504,45 @@ def test_wkt_empty_geometry_collection():
     assert_wkt_equivalence(gc)
 
 
+def test_geometry_collection_warnings():
+    point = Point(type="Point", coordinates=(0.0, 0.0, 0.0))
+    line_string = LineString(type="LineString", coordinates=[(0.0, 0.0), (1.0, 1.0)])
+
+    # one geometry
+    with pytest.warns(
+        UserWarning,
+        match="GeometryCollection should not be used for single geometries.",
+    ):
+        GeometryCollection(
+            type="GeometryCollection",
+            geometries=[
+                point,
+            ],
+        )
+
+    # collections of collections
+    with pytest.warns(
+        UserWarning,
+        match="GeometryCollection should not be used for nested GeometryCollections.",
+    ):
+        GeometryCollection(
+            type="GeometryCollection",
+            geometries=[
+                GeometryCollection(
+                    type="GeometryCollection", geometries=[point, line_string]
+                ),
+                point,
+            ],
+        )
+
+    # homogeneous geometry
+    with pytest.warns(
+        UserWarning,
+        match="GeometryCollection should not be used for homogeneous collections.",
+    ):
+        GeometryCollection(type="GeometryCollection", geometries=[point, point])
+
+
 def test_polygon_from_bounds():
     """Result from `from_bounds` class method should be the same."""
     coordinates = [[(1.0, 2.0), (3.0, 2.0), (3.0, 4.0), (1.0, 4.0), (1.0, 2.0)]]