Use shared bbox validator.

Author: eseglem

geojson_pydantic/features.py

@@ -7,7 +7,7 @@
 
 from geojson_pydantic.geo_interface import GeoInterfaceMixin
 from geojson_pydantic.geometries import Geometry, GeometryCollection
-from geojson_pydantic.types import BBox
+from geojson_pydantic.types import BBox, validate_bbox
 
 Props = TypeVar("Props", bound=Union[Dict[str, Any], BaseModel])
 Geom = TypeVar("Geom", bound=Union[Geometry, GeometryCollection])
@@ -22,6 +22,8 @@ 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)
+
     @validator("geometry", pre=True, always=True)
     def set_geometry(cls, geometry: Any) -> Any:
         """set geometry from geo interface or input"""
@@ -49,3 +51,5 @@ def __len__(self) -> int:
     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)

geojson_pydantic/geometries.py

@@ -19,6 +19,7 @@
     MultiPolygonCoords,
     PolygonCoords,
     Position,
+    validate_bbox,
 )
 
 
@@ -107,6 +108,8 @@ def wkt(self) -> str:
 
         return wkt
 
+    _validate_bbox = validator("bbox", allow_reuse=True)(validate_bbox)
+
 
 class Point(_GeometryBase):
     """Point Model"""
@@ -287,6 +290,8 @@ 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)
+
     @validator("geometries")
     def check_geometries(cls, geometries: List) -> List:
         """Add warnings for conditions the spec does not explicitly forbid."""

geojson_pydantic/types.py

@@ -1,63 +1,45 @@
 """Types for geojson_pydantic models"""
 
-from typing import TYPE_CHECKING, Any, Callable, Generator, List, Tuple, Union
+from typing import TYPE_CHECKING, List, Optional, Tuple, TypeVar, Union
 
-from pydantic import ConstrainedList, conlist
+from pydantic import conlist
 
+T = TypeVar("T")
 
-class _BBoxBase(ConstrainedList):
-    """Base Class with additional Validation for order."""
+BBox = Union[
+    Tuple[float, float, float, float], Tuple[float, float, float, float, float, float]
+]
 
-    # This is needed because pydantic checks it rather than `item_type`
-    __args__ = (float,)
 
-    item_type = float
+def validate_bbox(bbox: Optional[BBox]) -> Optional[BBox]:
+    """Validate BBox values are ordered correctly."""
+    # If bbox is None, there is nothing to validate.
+    if bbox is None:
+        return None
 
-    @classmethod
-    def __get_validators__(cls) -> Generator[Callable[..., Any], None, None]:
-        """Yield the validators."""
-        yield from super().__get_validators__()
-        yield cls.validate_bbox
+    # A list to store any errors found so we can raise them all at once.
+    errors: List[str] = []
 
-    @classmethod
-    def validate_bbox(cls, bbox: List[float]) -> List[float]:
-        """Validate BBox values are ordered correctly."""
-        if not bbox:
-            return bbox
+    # Determine where the second position starts. 2 for 2D, 3 for 3D.
+    offset = len(bbox) // 2
 
-        offset = len(bbox) // 2
-        errors: List[str] = []
-        # Check X
-        if bbox[0] > bbox[offset]:
-            errors.append(f"Min X ({bbox[0]}) must be <= Max X ({bbox[offset]}).")
-        # Check Y
-        if bbox[1] > bbox[1 + offset]:
-            errors.append(f"Min Y ({bbox[1]}) must be <= Max Y ({bbox[1 + offset]}).")
-        # If 3D, check Z values.
-        if offset > 2 and bbox[2] > bbox[2 + offset]:
-            errors.append(f"Min Z ({bbox[2]}) must be <= Max Z ({bbox[2 + offset]}).")
+    # Check X
+    if bbox[0] > bbox[offset]:
+        errors.append(f"Min X ({bbox[0]}) must be <= Max X ({bbox[offset]}).")
+    # Check Y
+    if bbox[1] > bbox[1 + offset]:
+        errors.append(f"Min Y ({bbox[1]}) must be <= Max Y ({bbox[1 + offset]}).")
+    # If 3D, check Z values.
+    if offset > 2 and bbox[2] > bbox[2 + offset]:
+        errors.append(f"Min Z ({bbox[2]}) must be <= Max Z ({bbox[2 + offset]}).")
 
-        if errors:
-            raise ValueError("Invalid BBox. Error(s): " + " ".join(errors))
+    # Raise any errors found.
+    if errors:
+        raise ValueError("Invalid BBox. Error(s): " + " ".join(errors))
 
-        return bbox
+    return bbox
 
 
-class BBox2D(_BBoxBase):
-    """2D Bounding Box"""
-
-    min_items = 4
-    max_items = 4
-
-
-class BBox3D(_BBoxBase):
-    """3D Bounding Box"""
-
-    min_items = 6
-    max_items = 6
-
-
-BBox = Union[BBox3D, BBox2D]
 Position = Union[Tuple[float, float], Tuple[float, float, float]]
 
 # Coordinate arrays

tests/test_features.py

@@ -232,8 +232,26 @@ def test_feature_validation():
 
     with pytest.raises(ValidationError):
         # bad bbox2d
-        Feature(type="Feature", properties=None, bbox=[100, 100, 0, 0])
+        Feature(type="Feature", properties=None, bbox=(100, 100, 0, 0), geometry=None)
 
     with pytest.raises(ValidationError):
         # bad bbox3d
-        Feature(type="Feature", properties=None, bbox=[100, 100, 100, 0, 0, 0])
+        Feature(
+            type="Feature",
+            properties=None,
+            bbox=(100, 100, 100, 0, 0, 0),
+            geometry=None,
+        )
+
+
+def test_bbox_validation():
+    # Some attempts at generic validation did not validate the types within
+    # bbox before passing them to the function and resulted in TypeErrors.
+    # This test exists to ensure that doesn't happen in the future.
+    with pytest.raises(ValidationError):
+        Feature(
+            type="Feature",
+            properties=None,
+            bbox=(0, "a", 0, 1, 1, 1),
+            geometry=None,
+        )