ad custom serializer to match GeoJSON spec

Author: vincentsarago

CHANGELOG.md

@@ -19,6 +19,8 @@ Note: Minor version `0.X.0` update might break the API, It's recommanded to pin
 
 ### Changed
 
+* update pydantic requirement to `~=2.0`
+
 * update pydantic `FeatureCollection` generic model to allow named features in the generated schemas.
 
     ```python
@@ -29,8 +31,6 @@ Note: Minor version `0.X.0` update might break the API, It's recommanded to pin
     FeatureCollection[Feature[Geometry, Properties]]
     ```
 
-* update pydantic requirement to `~=2.0`
-
 * raise `ValueError` in `geomtries.parse_geometry_obj` instead of `ValidationError`
 
     ```python
@@ -43,6 +43,19 @@ Note: Minor version `0.X.0` update might break the API, It's recommanded to pin
     >> ValueError("Unknown type: This type")
     ```
 
+* update JSON serializer to exclude null `bbox` and `id`
+
+    ```python
+    # before
+    Point(type="Point", coordinates=[0, 0]).json()
+    >> '{"type":"Point","coordinates":[0.0,0.0],"bbox":null}'
+
+    # now
+    Point(type="Point", coordinates=[0, 0]).model_dump_json()
+    >> '{"type":"Point","coordinates":[0.0,0.0]}'
+    ```
+
+
 ## [0.6.3] - 2023-07-02
 
 * limit pydantic requirement to `~=1.0`

geojson_pydantic/features.py

@@ -2,7 +2,14 @@
 
 from typing import Any, Dict, Generic, Iterator, List, Literal, Optional, TypeVar, Union
 
-from pydantic import BaseModel, Field, StrictInt, StrictStr, field_validator
+from pydantic import (
+    BaseModel,
+    Field,
+    StrictInt,
+    StrictStr,
+    field_validator,
+    model_serializer,
+)
 
 from geojson_pydantic.geo_interface import GeoInterfaceMixin
 from geojson_pydantic.geometries import Geometry
@@ -23,6 +30,21 @@ class Feature(BaseModel, Generic[Geom, Props], GeoInterfaceMixin):
 
     _validate_bbox = field_validator("bbox")(validate_bbox)
 
+    @model_serializer(when_used="json")
+    def ser_model(self) -> Dict[str, Any]:
+        """Custom Model serializer to match the GeoJSON specification."""
+        model: Dict[str, Any] = {
+            "type": self.type,
+            "geometry": self.geometry,
+            "properties": self.properties,
+        }
+        if self.id is not None:
+            model["id"] = self.id
+        if self.bbox:
+            model["bbox"] = self.bbox
+
+        return model
+
     @field_validator("geometry", mode="before")
     def set_geometry(cls, geometry: Any) -> Any:
         """set geometry from geo interface or input"""
@@ -42,6 +64,18 @@ class FeatureCollection(BaseModel, Generic[Feat], GeoInterfaceMixin):
     features: List[Feat]
     bbox: Optional[BBox] = None
 
+    @model_serializer(when_used="json")
+    def ser_model(self) -> Dict[str, Any]:
+        """Custom Model serializer to match the GeoJSON specification."""
+        model: Dict[str, Any] = {
+            "type": self.type,
+            "features": self.features,
+        }
+        if self.bbox:
+            model["bbox"] = self.bbox
+
+        return model
+
     def __iter__(self) -> Iterator[Feat]:  # type: ignore [override]
         """iterate over features"""
         return iter(self.features)

geojson_pydantic/geometries.py

@@ -3,9 +3,9 @@
 
 import abc
 import warnings
-from typing import Any, Iterator, List, Literal, Optional, Union
+from typing import Any, Dict, Iterator, List, Literal, Optional, Union
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_serializer
 from typing_extensions import Annotated
 
 from geojson_pydantic.geo_interface import GeoInterfaceMixin
@@ -79,6 +79,18 @@ class _GeometryBase(BaseModel, abc.ABC, GeoInterfaceMixin):
     coordinates: Any
     bbox: Optional[BBox] = None
 
+    @model_serializer(when_used="json")
+    def ser_model(self) -> Dict[str, Any]:
+        """Custom Model serializer to match the GeoJSON specification."""
+        model: Dict[str, Any] = {
+            "type": self.type,
+            "coordinates": self.coordinates,
+        }
+        if self.bbox:
+            model["bbox"] = self.bbox
+
+        return model
+
     @abc.abstractmethod
     def __wkt_coordinates__(self, coordinates: Any, force_z: bool) -> str:
         """return WKT coordinates."""
@@ -256,6 +268,18 @@ class GeometryCollection(BaseModel, GeoInterfaceMixin):
     geometries: List[Geometry]
     bbox: Optional[BBox] = None
 
+    @model_serializer(when_used="json")
+    def ser_model(self) -> Dict[str, Any]:
+        """Custom Model serializer to match the GeoJSON specification."""
+        model: Dict[str, Any] = {
+            "type": self.type,
+            "geometries": self.geometries,
+        }
+        if self.bbox:
+            model["bbox"] = self.bbox
+
+        return model
+
     def __iter__(self) -> Iterator[Geometry]:  # type: ignore [override]
         """iterate over geometries"""
         return iter(self.geometries)

tests/test_features.py

@@ -1,3 +1,4 @@
+import json
 from random import randint
 from typing import Any, Dict
 from uuid import uuid4
@@ -302,3 +303,107 @@ def test_feature_validation_error_count():
         except ValidationError as e:
             assert e.error_count() == 1
             raise
+
+
+def test_feature_serializer():
+    f = Feature(
+        **{
+            "type": "Feature",
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": coordinates,
+            },
+            "properties": {},
+            "id": "Yo",
+            "bbox": [13.38272, 52.46385, 13.42786, 52.48445],
+        }
+    )
+    assert "bbox" in f.model_dump()
+    assert "id" in f.model_dump()
+
+    feat_ser = json.loads(f.model_dump_json())
+    assert "bbox" in feat_ser
+    assert "id" in feat_ser
+    assert "bbox" not in feat_ser["geometry"]
+
+    f = Feature(
+        **{
+            "type": "Feature",
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": coordinates,
+            },
+            "properties": {},
+        }
+    )
+    assert "bbox" in f.model_dump()
+
+    feat_ser = json.loads(f.model_dump_json())
+    assert "bbox" not in feat_ser
+    assert "id" not in feat_ser
+    assert "bbox" not in feat_ser["geometry"]
+
+    f = Feature(
+        **{
+            "type": "Feature",
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": coordinates,
+                "bbox": [13.38272, 52.46385, 13.42786, 52.48445],
+            },
+            "properties": {},
+        }
+    )
+    feat_ser = json.loads(f.model_dump_json())
+    assert "bbox" not in feat_ser
+    assert "id" not in feat_ser
+    assert "bbox" in feat_ser["geometry"]
+
+
+def test_feature_collection_serializer():
+    fc = FeatureCollection(
+        **{
+            "type": "FeatureCollection",
+            "features": [
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "Polygon",
+                        "coordinates": coordinates,
+                        "bbox": [13.38272, 52.46385, 13.42786, 52.48445],
+                    },
+                    "properties": {},
+                    "bbox": [13.38272, 52.46385, 13.42786, 52.48445],
+                }
+            ],
+            "bbox": [13.38272, 52.46385, 13.42786, 52.48445],
+        }
+    )
+    assert "bbox" in fc.model_dump()
+
+    featcoll_ser = json.loads(fc.model_dump_json())
+    assert "bbox" in featcoll_ser
+    assert "bbox" in featcoll_ser["features"][0]
+    assert "bbox" in featcoll_ser["features"][0]["geometry"]
+
+    fc = FeatureCollection(
+        **{
+            "type": "FeatureCollection",
+            "features": [
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "Polygon",
+                        "coordinates": coordinates,
+                    },
+                    "properties": {},
+                }
+            ],
+        }
+    )
+    assert "bbox" in fc.model_dump()
+
+    featcoll_ser = json.loads(fc.model_dump_json())
+    assert "bbox" not in featcoll_ser
+    assert "bbox" not in featcoll_ser["features"][0]
+    assert "bbox" not in featcoll_ser["features"][0]["geometry"]

tests/test_geometries.py

@@ -1,8 +1,11 @@
+import json
+
 import pytest
 import shapely
 from pydantic import ValidationError
 
 from geojson_pydantic.geometries import (
+    Geometry,
     GeometryCollection,
     LineString,
     MultiLineString,
@@ -761,3 +764,111 @@ def test_wkt(wkt: str):
     # Use Shapely to parse the input WKT so we know it is parsable by other tools.
     # Then load it into a Geometry and ensure the output WKT is the same as the input.
     assert parse_geometry_obj(shapely.from_wkt(wkt).__geo_interface__).wkt == wkt
+
+
+@pytest.mark.parametrize(
+    "geom",
+    (
+        Point(type="Point", coordinates=[0, 0], bbox=[0, 0, 0, 0]),
+        Point(type="Point", coordinates=[0, 0]),
+        MultiPoint(type="MultiPoint", coordinates=[(0.0, 0.0)], bbox=[0, 0, 0, 0]),
+        MultiPoint(type="MultiPoint", coordinates=[(0.0, 0.0)]),
+        LineString(
+            type="LineString", coordinates=[(0.0, 0.0), (1.0, 1.0)], bbox=[0, 0, 1, 1]
+        ),
+        LineString(type="LineString", coordinates=[(0.0, 0.0), (1.0, 1.0)]),
+        MultiLineString(
+            type="MultiLineString",
+            coordinates=[[(0.0, 0.0), (1.0, 1.0)]],
+            bbox=[0, 0, 1, 1],
+        ),
+        MultiLineString(type="MultiLineString", coordinates=[[(0.0, 0.0), (1.0, 1.0)]]),
+        Polygon(
+            type="Polygon",
+            coordinates=[[(1.0, 2.0), (3.0, 4.0), (5.0, 6.0), (1.0, 2.0)]],
+            bbox=[1.0, 2.0, 5.0, 6.0],
+        ),
+        Polygon(
+            type="Polygon",
+            coordinates=[[(1.0, 2.0), (3.0, 4.0), (5.0, 6.0), (1.0, 2.0)]],
+        ),
+        MultiPolygon(
+            type="MultiPolygon",
+            coordinates=[[[(1.0, 2.0), (3.0, 4.0), (5.0, 6.0), (1.0, 2.0)]]],
+            bbox=[1.0, 2.0, 5.0, 6.0],
+        ),
+        MultiPolygon(
+            type="MultiPolygon",
+            coordinates=[[[(1.0, 2.0), (3.0, 4.0), (5.0, 6.0), (1.0, 2.0)]]],
+        ),
+    ),
+)
+def test_geometry_serializer(geom: Geometry):
+    # bbox should always be in the dictionary version of the model
+    # but should only be in the JSON version if not None
+    assert "bbox" in geom.model_dump()
+    if geom.bbox is not None:
+        assert "bbox" in geom.model_dump_json()
+    else:
+        assert "bbox" not in geom.model_dump_json()
+
+
+def test_geometry_collection_serializer():
+    geom = GeometryCollection(
+        type="GeometryCollection",
+        geometries=[
+            Point(type="Point", coordinates=[0, 0]),
+            LineString(type="LineString", coordinates=[(0.0, 0.0), (1.0, 1.0)]),
+        ],
+    )
+    # bbox will be in the Dict
+    assert "bbox" in geom.model_dump()
+    assert "bbox" in geom.model_dump()["geometries"][0]
+
+    # bbox should not be in any Geometry nor at the top level
+    geom_ser = json.loads(geom.model_dump_json())
+    assert "bbox" not in geom_ser
+    assert "bbox" not in geom_ser["geometries"][0]
+    assert "bbox" not in geom_ser["geometries"][0]
+
+    geom = GeometryCollection(
+        type="GeometryCollection",
+        geometries=[
+            Point(type="Point", coordinates=[0, 0], bbox=[0, 0, 0, 0]),
+            LineString(type="LineString", coordinates=[(0.0, 0.0), (1.0, 1.0)]),
+        ],
+    )
+    # bbox not in the top level but in the first geometry (point)
+    geom_ser = json.loads(geom.model_dump_json())
+    assert "bbox" not in geom_ser
+    assert "bbox" in geom_ser["geometries"][0]
+    assert "bbox" not in geom_ser["geometries"][1]
+
+    geom = GeometryCollection(
+        type="GeometryCollection",
+        geometries=[
+            Point(type="Point", coordinates=[0, 0], bbox=[0, 0, 0, 0]),
+            LineString(
+                type="LineString",
+                coordinates=[(0.0, 0.0), (1.0, 1.0)],
+                bbox=[0, 0, 1, 1],
+            ),
+        ],
+    )
+    geom_ser = json.loads(geom.model_dump_json())
+    assert "bbox" not in geom_ser
+    assert "bbox" in geom_ser["geometries"][0]
+    assert "bbox" in geom_ser["geometries"][1]
+
+    geom = GeometryCollection(
+        type="GeometryCollection",
+        geometries=[
+            Point(type="Point", coordinates=[0, 0]),
+            LineString(type="LineString", coordinates=[(0.0, 0.0), (1.0, 1.0)]),
+        ],
+        bbox=[0, 0, 1, 1],
+    )
+    geom_ser = json.loads(geom.model_dump_json())
+    assert "bbox" in geom_ser
+    assert "bbox" not in geom_ser["geometries"][0]
+    assert "bbox" not in geom_ser["geometries"][1]