enforce type, geometry and properties

Author: vincentsarago

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.8', '3.9', '3.10', '3.11']
 
     steps:
       - uses: actions/checkout@v3

geojson_pydantic/features.py

@@ -1,6 +1,6 @@
 """pydantic models for GeoJSON Feature objects."""
 
-from typing import Any, Dict, Generic, Iterator, List, Optional, TypeVar, Union
+from typing import Any, Dict, Generic, Iterator, List, Literal, Optional, TypeVar, Union
 
 from pydantic import BaseModel, Field, validator
 from pydantic.generics import GenericModel
@@ -15,9 +15,9 @@
 class Feature(GenericModel, Generic[Geom, Props]):
     """Feature Model"""
 
-    type: str = Field(default="Feature", const=True)
-    geometry: Optional[Geom] = None
-    properties: Optional[Props] = None
+    type: Literal["Feature"]
+    geometry: Union[Geom, None] = Field(...)
+    properties: Props = Field(...)
     id: Optional[str] = None
     bbox: Optional[BBox] = None
 
@@ -29,9 +29,11 @@ class Config:
     @validator("geometry", pre=True, always=True)
     def set_geometry(cls, geometry: Any) -> Any:
         """set geometry from geo interface or input"""
-        if hasattr(geometry, "__geo_interface__"):
-            return geometry.__geo_interface__
-        return geometry
+        if geometry is not None:
+            if hasattr(geometry, "__geo_interface__"):
+                return geometry.__geo_interface__
+
+            return geometry
 
     @property
     def __geo_interface__(self) -> Dict[str, Any]:
@@ -44,23 +46,22 @@ def __geo_interface__(self) -> Dict[str, Any]:
             "geometry": self.geometry.__geo_interface__
             if self.geometry is not None
             else None,
+            "properties": self.properties,
         }
+
         if self.bbox:
             geo["bbox"] = self.bbox
 
         if self.id:
             geo["id"] = self.id
 
-        if self.properties:
-            geo["properties"] = self.properties
-
         return geo
 
 
 class FeatureCollection(GenericModel, Generic[Geom, Props]):
     """FeatureCollection Model"""
 
-    type: str = Field(default="FeatureCollection", const=True)
+    type: Literal["FeatureCollection"]
     features: List[Feature[Geom, Props]]
     bbox: Optional[BBox] = None
 

geojson_pydantic/geometries.py

@@ -1,9 +1,9 @@
 """pydantic models for GeoJSON Geometry objects."""
 
 import abc
-from typing import Any, Dict, Iterator, List, Union
+from typing import Any, Dict, Iterator, List, Literal, Union
 
-from pydantic import BaseModel, Field, ValidationError, validator
+from pydantic import BaseModel, ValidationError, validator
 from pydantic.error_wrappers import ErrorWrapper
 
 from geojson_pydantic.types import (
@@ -56,7 +56,7 @@ def wkt(self) -> str:
 class Point(_GeometryBase):
     """Point Model"""
 
-    type: str = Field(default="Point", const=True)
+    type: Literal["Point"]
     coordinates: Position
 
     @property
@@ -71,7 +71,7 @@ def _wkt_inset(self) -> str:
 class MultiPoint(_GeometryBase):
     """MultiPoint Model"""
 
-    type: str = Field(default="MultiPoint", const=True)
+    type: Literal["MultiPoint"]
     coordinates: MultiPointCoords
 
     @property
@@ -80,14 +80,14 @@ def _wkt_inset(self) -> str:
 
     @property
     def _wkt_coordinates(self) -> str:
-        points = [Point(coordinates=p) for p in self.coordinates]
+        points = [Point(type="Point", coordinates=p) for p in self.coordinates]
         return ", ".join(point._wkt_coordinates for point in points)
 
 
 class LineString(_GeometryBase):
     """LineString Model"""
 
-    type: str = Field(default="LineString", const=True)
+    type: Literal["LineString"]
     coordinates: LineStringCoords
 
     @property
@@ -96,14 +96,14 @@ def _wkt_inset(self) -> str:
 
     @property
     def _wkt_coordinates(self) -> str:
-        points = [Point(coordinates=p) for p in self.coordinates]
+        points = [Point(type="Point", coordinates=p) for p in self.coordinates]
         return ", ".join(point._wkt_coordinates for point in points)
 
 
 class MultiLineString(_GeometryBase):
     """MultiLineString Model"""
 
-    type: str = Field(default="MultiLineString", const=True)
+    type: Literal["MultiLineString"]
     coordinates: MultiLineStringCoords
 
     @property
@@ -112,7 +112,9 @@ def _wkt_inset(self) -> str:
 
     @property
     def _wkt_coordinates(self) -> str:
-        lines = [LineString(coordinates=line) for line in self.coordinates]
+        lines = [
+            LineString(type="LineString", coordinates=line) for line in self.coordinates
+        ]
         return ",".join(f"({line._wkt_coordinates})" for line in lines)
 
 
@@ -131,7 +133,7 @@ def check_closure(cls, coordinates: List) -> List:
 class Polygon(_GeometryBase):
     """Polygon Model"""
 
-    type: str = Field(default="Polygon", const=True)
+    type: Literal["Polygon"]
     coordinates: PolygonCoords
 
     @validator("coordinates")
@@ -161,27 +163,28 @@ def _wkt_inset(self) -> str:
     @property
     def _wkt_coordinates(self) -> str:
         ic = "".join(
-            f", ({LinearRingGeom(coordinates=interior)._wkt_coordinates})"
+            f", ({LinearRingGeom(type='LineString', coordinates=interior)._wkt_coordinates})"
             for interior in self.interiors
         )
-        return f"({LinearRingGeom(coordinates=self.exterior)._wkt_coordinates}){ic}"
+        return f"({LinearRingGeom(type='LineString', coordinates=self.exterior)._wkt_coordinates}){ic}"
 
     @classmethod
     def from_bounds(
         cls, xmin: float, ymin: float, xmax: float, ymax: float
     ) -> "Polygon":
         """Create a Polygon geometry from a boundingbox."""
         return cls(
+            type="Polygon",
             coordinates=[
                 [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax), (xmin, ymin)]
-            ]
+            ],
         )
 
 
 class MultiPolygon(_GeometryBase):
     """MultiPolygon Model"""
 
-    type: str = Field(default="MultiPolygon", const=True)
+    type: Literal["MultiPolygon"]
     coordinates: MultiPolygonCoords
 
     @property
@@ -190,7 +193,9 @@ def _wkt_inset(self) -> str:
 
     @property
     def _wkt_coordinates(self) -> str:
-        polygons = [Polygon(coordinates=poly) for poly in self.coordinates]
+        polygons = [
+            Polygon(type="Polygon", coordinates=poly) for poly in self.coordinates
+        ]
         return ",".join(f"({poly._wkt_coordinates})" for poly in polygons)
 
 
@@ -200,7 +205,7 @@ def _wkt_coordinates(self) -> str:
 class GeometryCollection(BaseModel):
     """GeometryCollection Model"""
 
-    type: str = Field(default="GeometryCollection", const=True)
+    type: Literal["GeometryCollection"]
     geometries: List[Geometry]
 
     def __iter__(self) -> Iterator[Geometry]:  # type: ignore [override]

pyproject.toml

@@ -2,7 +2,7 @@
 name = "geojson-pydantic"
 description = "Pydantic data models for the GeoJSON spec."
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 license = {file = "LICENSE"}
 authors = [
     {name = "Drew Bollinger", email = "[email protected]"},
@@ -12,7 +12,6 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",

tests/test_features.py

@@ -66,14 +66,18 @@ class GenericProperties(BaseModel):
 
 def test_feature_collection_iteration():
     """test if feature collection is iterable"""
-    gc = FeatureCollection(features=[test_feature, test_feature])
+    gc = FeatureCollection(
+        type="FeatureCollection", features=[test_feature, test_feature]
+    )
     assert hasattr(gc, "__geo_interface__")
     iter(gc)
 
 
 def test_geometry_collection_iteration():
     """test if feature collection is iterable"""
-    gc = FeatureCollection(features=[test_feature_geometry_collection])
+    gc = FeatureCollection(
+        type="FeatureCollection", features=[test_feature_geometry_collection]
+    )
     assert hasattr(gc, "__geo_interface__")
     iter(gc)
 
@@ -152,7 +156,7 @@ def test_generic_properties_should_raise_for_string():
 
 def test_feature_collection_generic():
     fc = FeatureCollection[Polygon, GenericProperties](
-        features=[test_feature, test_feature]
+        type="FeatureCollection", features=[test_feature, test_feature]
     )
     assert len(fc) == 2
     assert type(fc[0].properties) == GenericProperties
@@ -163,7 +167,7 @@ def test_geo_interface_protocol():
     class Pointy:
         __geo_interface__ = {"type": "Point", "coordinates": (0.0, 0.0)}
 
-    feat = Feature(geometry=Pointy())
+    feat = Feature(type="Feature", geometry=Pointy(), properties={})
     assert feat.geometry.dict() == Pointy.__geo_interface__
 
 
@@ -178,7 +182,9 @@ def test_feature_geo_interface_with_null_geometry():
 
 
 def test_feature_collection_geo_interface_with_null_geometry():
-    fc = FeatureCollection(features=[test_feature_geom_null, test_feature])
+    fc = FeatureCollection(
+        type="FeatureCollection", features=[test_feature_geom_null, test_feature]
+    )
     assert "bbox" not in fc.__geo_interface__
     assert "bbox" not in fc.__geo_interface__["features"][0]
     assert "bbox" in fc.__geo_interface__["features"][1]