Merge pull request #130 from developmentseed/pydantic2.0

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,18 +2,17 @@
 
 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
+from geojson_pydantic.geometries import Geometry
 from geojson_pydantic.types import BBox, validate_bbox
 
 Props = TypeVar("Props", bound=Union[Dict[str, Any], BaseModel])
-Geom = TypeVar("Geom", bound=Union[Geometry, GeometryCollection])
+Geom = TypeVar("Geom", bound=Geometry)
 
 
-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/geo_interface.py

@@ -3,10 +3,10 @@
 from typing import Any, Dict, Protocol
 
 
-class _DictProtocol(Protocol):
+class _ModelDumpProtocol(Protocol):
     """Protocol for use as the type of self in the mixin."""
 
-    def dict(self, *, exclude_unset: bool, **args: Any) -> Dict[str, Any]:
+    def model_dump(self, *, exclude_unset: bool, **args: Any) -> Dict[str, Any]:
         """Define a dict function so the mixin knows it exists."""
         ...
 
@@ -15,9 +15,9 @@ class GeoInterfaceMixin:
     """Mixin for __geo_interface__ on GeoJSON objects."""
 
     @property
-    def __geo_interface__(self: _DictProtocol) -> Dict[str, Any]:
+    def __geo_interface__(self: _ModelDumpProtocol) -> Dict[str, Any]:
         """GeoJSON-like protocol for geo-spatial (GIS) vector data.
 
         ref: https://gist.github.com/sgillies/2217756#__geo_interface
         """
-        return self.dict(exclude_unset=True)
+        return self.model_dump(exclude_unset=True)

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):
@@ -247,28 +246,22 @@ def check_closure(cls, coordinates: List) -> List:
         return coordinates
 
 
-Geometry = Annotated[
-    Union[Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon],
-    Field(discriminator="type"),
-]
-
-
 class GeometryCollection(BaseModel, GeoInterfaceMixin):
     """GeometryCollection Model"""
 
     type: Literal["GeometryCollection"]
-    geometries: List[Union[Geometry, GeometryCollection]]
+    geometries: List[Geometry]
     bbox: Optional[BBox] = None
 
-    def __iter__(self) -> Iterator[Union[Geometry, GeometryCollection]]:  # type: ignore [override]
+    def __iter__(self) -> Iterator[Geometry]:  # type: ignore [override]
         """iterate over geometries"""
         return iter(self.geometries)
 
     def __len__(self) -> int:
         """return geometries length"""
         return len(self.geometries)
 
-    def __getitem__(self, index: int) -> Union[Geometry, GeometryCollection]:
+    def __getitem__(self, index: int) -> Geometry:
         """get geometry at a given index"""
         return self.geometries[index]
 
@@ -290,51 +283,70 @@ 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
 
 
+Geometry = Annotated[
+    Union[
+        Point,
+        MultiPoint,
+        LineString,
+        MultiLineString,
+        Polygon,
+        MultiPolygon,
+        GeometryCollection,
+    ],
+    Field(discriminator="type"),
+]
+
+
 def parse_geometry_obj(obj: Any) -> Geometry:
     """
     `obj` is an object that is supposed to represent a GeoJSON geometry. This method returns the
     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)
+        return Point.model_validate(obj)
+
     elif obj["type"] == "MultiPoint":
-        return MultiPoint.parse_obj(obj)
+        return MultiPoint.model_validate(obj)
+
     elif obj["type"] == "LineString":
-        return LineString.parse_obj(obj)
+        return LineString.model_validate(obj)
+
     elif obj["type"] == "MultiLineString":
-        return MultiLineString.parse_obj(obj)
+        return MultiLineString.model_validate(obj)
+
     elif obj["type"] == "Polygon":
-        return Polygon.parse_obj(obj)
+        return Polygon.model_validate(obj)
+
     elif obj["type"] == "MultiPolygon":
-        return MultiPolygon.parse_obj(obj)
-    raise ValidationError(
-        errors=[ErrorWrapper(ValueError("Unknown type"), loc="type")],
-        model=_GeometryBase,
-    )
+        return MultiPolygon.model_validate(obj)
+
+    elif obj["type"] == "GeometryCollection":
+        return GeometryCollection.model_validate(obj)
+
+    raise ValueError(f"Unknown type: {obj['type']}")

geojson_pydantic/types.py

@@ -1,8 +1,9 @@
 """Types for geojson_pydantic models"""
 
-from typing import TYPE_CHECKING, List, Optional, Tuple, TypeVar, Union
+from typing import List, Optional, Tuple, TypeVar, Union
 
-from pydantic import conlist
+from pydantic import Field
+from typing_extensions import Annotated
 
 T = TypeVar("T")
 
@@ -44,13 +45,8 @@ def validate_bbox(bbox: Optional[BBox]) -> Optional[BBox]:
 Position = Union[Tuple[float, float], Tuple[float, float, float]]
 
 # Coordinate arrays
-if TYPE_CHECKING:
-    LineStringCoords = List[Position]
-    LinearRing = List[Position]
-else:
-    LineStringCoords = conlist(Position, min_items=2)
-    LinearRing = conlist(Position, min_items=4)
-
+LineStringCoords = Annotated[List[Position], Field(min_length=2)]
+LinearRing = Annotated[List[Position], Field(min_length=4)]
 MultiPointCoords = List[Position]
 MultiLineStringCoords = List[LineStringCoords]
 PolygonCoords = List[LinearRing]

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_features.py

@@ -174,7 +174,7 @@ class Pointy:
         __geo_interface__ = {"type": "Point", "coordinates": (0.0, 0.0)}
 
     feat = Feature(type="Feature", geometry=Pointy(), properties={})
-    assert feat.geometry.dict(exclude_unset=True) == Pointy.__geo_interface__
+    assert feat.geometry.model_dump(exclude_unset=True) == Pointy.__geo_interface__
 
 
 def test_feature_with_null_geometry():
@@ -263,3 +263,30 @@ def test_bbox_validation():
             bbox=(0, "a", 0, 1, 1, 1),
             geometry=None,
         )
+
+
+def test_feature_validation_error_count():
+    # Tests that validation does not include irrelevant errors to make them
+    # easier to read. The input below used to raise 18 errors.
+    # See #93 for more details.
+    with pytest.raises(ValidationError):
+        try:
+            Feature(
+                type="Feature",
+                geometry=Polygon(
+                    type="Polygon",
+                    coordinates=[
+                        [
+                            (-55.9947406591177, -9.26104045526505),
+                            (-55.9976752102375, -9.266589696568962),
+                            (-56.00200328975916, -9.264041751931352),
+                            (-55.99899921566248, -9.257935213034594),
+                            (-55.99477406591177, -9.26103945526505),
+                        ]
+                    ],
+                ),
+                properties={},
+            )
+        except ValidationError as e:
+            assert e.error_count() == 1
+            raise