django-gisserver 2.0__py3-none-any.whl → 2.1__py3-none-any.whl

gisserver/features.py

@@ -1,14 +1,15 @@
-"""The configuration of a "feature type" in the WFS server.
+"""The main configuration for exposing model data in the WFS server.
 
 The "feature type" definitions define what models and attributes are exposed in the WFS server.
 When a model attribute is mentioned in the feature type, it can be exposed and queried against.
 Any field that is not mentioned in a definition, will therefore not be available, nor queryable.
 This metadata is used in the ``GetCapabilities`` call to advertise all available feature types.
 
-To handle other WFS request types besides ``GetCapabilities``, the "feature type" definition
-is translated internally into an internal XML Schema Definition (:mod:`gisserver.types`).
+The "feature type" definitions ares translated internally into
+an internal XML Schema Definition (made from :mod:`gisserver.types`).
 That schema maps all model attributes to a specific XML layout, and includes
 all XSD Complex Types, elements and attributes linked to the Django model metadata.
+
 The feature type classes (and field types) offer a flexible translation
 from attribute listings into a schema definition.
 For example, model relationships can be modelled to a different XML layout.
@@ -21,19 +22,20 @@ import itertools
 import logging
 from dataclasses import dataclass
 from functools import cached_property, lru_cache
-from typing import TYPE_CHECKING, Literal, Union
+from typing import TYPE_CHECKING, Literal
 
 from django.contrib.gis.db import models as gis_models
-from django.contrib.gis.db.models import Extent, GeometryField
+from django.contrib.gis.db.models import GeometryField
 from django.core.exceptions import FieldDoesNotExist, ImproperlyConfigured
 from django.db import models
 from django.http import HttpRequest
 
 from gisserver import conf
 from gisserver.compat import ArrayField, GeneratedField
-from gisserver.db import get_db_geometry_target
+from gisserver.crs import CRS
+from gisserver.db import get_wgs84_bounding_box
 from gisserver.exceptions import ExternalValueError, InvalidParameterValue
-from gisserver.geometries import CRS, WGS84, BoundingBox
+from gisserver.geometries import WGS84BoundingBox
 from gisserver.parsers.xml import parse_qname, xmlns
 from gisserver.types import (
     GeometryXsdElement,
@@ -50,14 +52,11 @@ from gisserver.types import (
 if TYPE_CHECKING:
     from gisserver.projection import FeatureRelation
 
-_all_ = Literal["__all__"]
-
 __all__ = [
     "FeatureType",
     "field",
     "FeatureField",
     "ComplexFeatureField",
-    "get_basic_field_type",
 ]
 
 logger = logging.getLogger(__name__)
@@ -67,12 +66,16 @@ XSD_TYPES = {
     models.TextField: XsdTypes.string,
     models.BooleanField: XsdTypes.boolean,
     models.IntegerField: XsdTypes.integer,
+    models.PositiveIntegerField: XsdTypes.nonNegativeInteger,
+    models.PositiveBigIntegerField: XsdTypes.nonNegativeInteger,
+    models.PositiveSmallIntegerField: XsdTypes.nonNegativeInteger,
     models.AutoField: XsdTypes.integer,  # Only as of Django 3.0 this extends from IntegerField
     models.FloatField: XsdTypes.double,
     models.DecimalField: XsdTypes.decimal,
     models.TimeField: XsdTypes.time,
     models.DateTimeField: XsdTypes.dateTime,  # note: DateTimeField extends DateField!
     models.DateField: XsdTypes.date,
+    models.DurationField: XsdTypes.duration,
     models.URLField: XsdTypes.anyURI,
     gis_models.PointField: XsdTypes.gmlPointPropertyType,
     gis_models.PolygonField: XsdTypes.gmlSurfacePropertyType,
@@ -87,7 +90,7 @@ XSD_TYPES = {
 DEFAULT_XSD_TYPE = XsdTypes.anyType
 
 
-def get_basic_field_type(
+def _get_basic_field_type(
     field_name: str, model_field: models.Field | models.ForeignObjectRel
 ) -> XsdAnyType:
     """Determine the XSD field type for a Django field."""
@@ -108,10 +111,10 @@ def get_basic_field_type(
 
     if isinstance(model_field, models.ForeignKey):
         # Don't let it query on the relation value yet
-        return get_basic_field_type(field_name, model_field.target_field)
+        return _get_basic_field_type(field_name, model_field.target_field)
     elif isinstance(model_field, models.ForeignObjectRel):
         # e.g. ManyToOneRel descriptor of a foreignkey_id field.
-        return get_basic_field_type(field_name, model_field.remote_field.target_field)
+        return _get_basic_field_type(field_name, model_field.remote_field.target_field)
     else:
         # Subclass checks:
         for field_cls, xsd_type in XSD_TYPES.items():
@@ -128,7 +131,7 @@ def get_basic_field_type(
 
 def _get_model_fields(
     model: type[models.Model],
-    fields: _all_ | list[str],
+    fields: list[str] | Literal["__all__"],
     parent: ComplexFeatureField | None = None,
     feature_type: FeatureType | None = None,
 ):
@@ -230,7 +233,7 @@ class FeatureField:
             )
 
     def _get_xsd_type(self):
-        return get_basic_field_type(self.name, self.model_field)
+        return _get_basic_field_type(self.name, self.model_field)
 
     def bind(
         self,
@@ -349,10 +352,6 @@ class FeatureField:
         )
 
 
-_FieldDefinition = Union[str, FeatureField]
-_FieldDefinitions = Union[_all_, list[_FieldDefinition]]
-
-
 class ComplexFeatureField(FeatureField):
     """The configuration for an embedded relation field.
 
@@ -364,7 +363,7 @@ class ComplexFeatureField(FeatureField):
     def __init__(
         self,
         name: str,
-        fields: _FieldDefinitions,
+        fields: list[str | FeatureField] | Literal["__all__"],
         model_attribute=None,
         model=None,
         abstract=None,
@@ -439,7 +438,7 @@ def field(
     *,
     model_attribute=None,
     abstract: str | None = None,
-    fields: _FieldDefinitions | None = None,
+    fields: list[str | FeatureField] | Literal["__all__"] | None = None,
     xsd_class: type[XsdElement] | None = None,
 ) -> FeatureField:
     """Shortcut to define a WFS field.
@@ -490,7 +489,7 @@ class FeatureType:
         self,
         queryset: models.QuerySet,
         *,
-        fields: _FieldDefinitions | None = None,
+        fields: list[str | FeatureField] | Literal["__all__"] | None = None,
         display_field_name: str | None = None,
         geometry_field_name: str | None = None,
         name: str | None = None,
@@ -553,6 +552,13 @@ class FeatureType:
 
         self._cached_resolver = lru_cache(200)(self._inner_resolve_element)
 
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__qualname__}: {self.xml_name},"
+            f" fields={self.fields!r},"
+            f" geometry_field_name={self.main_geometry_element.absolute_model_attribute!r}>"
+        )
+
     def bind_namespace(self, default_xml_namespace: str):
         """Make sure the feature type receives the settings from the parent view."""
         if not self.xml_namespace:
@@ -709,19 +715,20 @@ class FeatureType:
         """When a related object returns a queryset, this hook allows extra filtering."""
         return queryset
 
-    def get_bounding_box(self) -> BoundingBox | None:
+    def get_bounding_box(self) -> WGS84BoundingBox | None:
         """Returns a WGS84 BoundingBox for the complete feature.
 
         This is used by the GetCapabilities request. It may return ``None``
         when the database table is empty, or the custom queryset doesn't
         return any results.
+
+        Note that the ``<ows:WGS84BoundingBox>`` element always uses longitude/latitude,
+        as it doesn't describe a CRS.
         """
         if not self.main_geometry_element:
             return None
 
-        geo_expression = get_db_geometry_target(self.main_geometry_element, WGS84)
-        bbox = self.get_queryset().aggregate(a=Extent(geo_expression))["a"]
-        return BoundingBox(*bbox, crs=WGS84) if bbox else None
+        return get_wgs84_bounding_box(self.get_queryset(), self.main_geometry_element)
 
     def get_display_value(self, instance: models.Model) -> str:
         """Generate the display name value"""
@@ -839,18 +846,19 @@ class FeatureType:
 
     def resolve_crs(self, crs: CRS, locator="") -> CRS:
         """Check a parsed CRS against the list of supported types."""
-        pos = self.supported_crs.index(crs)
-        if pos != -1:
+        try:
+            pos = self.supported_crs.index(crs)
+
             # Replace the parsed CRS with the declared one, which may have a 'backend' configured.
             return self.supported_crs[pos]
-
-        if conf.GISSERVER_SUPPORTED_CRS_ONLY:
-            raise InvalidParameterValue(
-                f"Feature '{self.name}' does not support SRID {crs.srid}.",
-                locator=locator,
-            )
-        else:
-            return crs
+        except ValueError:
+            if conf.GISSERVER_SUPPORTED_CRS_ONLY:
+                raise InvalidParameterValue(
+                    f"Feature '{self.name}' does not support SRID {crs.srid}.",
+                    locator=locator,
+                ) from None
+            else:
+                return crs
 
 
 class HDict(dict):

gisserver/geometries.py

@@ -1,340 +1,86 @@
 """Helper classes to handle geometry data types.
 
-This includes the CRS parsing, coordinate transforms and bounding box object.
 The bounding box can be calculated within Python, or read from a database result.
 """
 
 from __future__ import annotations
 
-import logging
-import re
-from dataclasses import dataclass, field
-from decimal import Decimal
-from functools import cached_property, lru_cache
+import math
+from dataclasses import dataclass
 
-from django.contrib.gis.gdal import AxisOrder, CoordTransform, SpatialReference
 from django.contrib.gis.geos import GEOSGeometry
 
-from gisserver.exceptions import ExternalValueError
+from gisserver.crs import CRS, CRS84, WEB_MERCATOR, WGS84  # noqa: F401 (keep old exports)
 
-CRS_URN_REGEX = re.compile(
-    r"^urn:(?P<domain>[a-z]+)"
-    r":def:crs:(?P<authority>[a-z]+)"
-    r":(?P<version>[0-9]+\.[0-9]+(\.[0-9]+)?)?"
-    r":(?P<id>[0-9]+|crs84)"
-    r"$",
-    re.IGNORECASE,
-)
+#: The CRS for the ``<ows:WGS84BoundingBox>`` element:
+WGS84_BOUNDING_BOX_CRS = CRS.from_string("urn:ogc:def:crs:OGC:2:84")
 
 __all__ = [
-    "CRS",
-    "WEB_MERCATOR",
-    "WGS84",
     "BoundingBox",
+    "WGS84BoundingBox",
 ]
 
-logger = logging.getLogger(__name__)
 
+@dataclass
+class BoundingBox:
+    """A bounding box.
+    Due to the overlap between 2 types, this element is used for 2 cases:
 
-@lru_cache(maxsize=200)  # Using lru-cache to avoid repeated GDAL c-object construction
-def _get_spatial_reference(srs_input: str | int, srs_type="user", axis_order=None):
-    """Construct an GDAL object reference"""
-    if axis_order is None:
-        # WFS 1.0 used x/y coordinates, WFS 2.0 uses the ordering from the CRS authority.
-        axis_order = AxisOrder.AUTHORITY
-
-    logger.debug(
-        "Constructed GDAL SpatialReference(%r, srs_type=%r, axis_order=%s)",
-        srs_input,
-        srs_type,
-        axis_order,
-    )
-    return SpatialReference(srs_input, srs_type=srs_type, axis_order=axis_order)
-
-
-@lru_cache(maxsize=100)
-def _get_coord_transform(
-    source: int | SpatialReference, target: int | SpatialReference
-) -> CoordTransform:
-    """Get an efficient coordinate transformation object.
-
-    The CoordTransform should be used when performing the same
-    coordinate transformation repeatedly on different geometries.
-
-    NOTE that the cache could be busted when CRS objects are
-    repeatedly created with a custom 'backend' object.
-    """
-    if isinstance(source, int):
-        source = _get_spatial_reference(source, srs_type="epsg")
-    if isinstance(target, int):
-        target = _get_spatial_reference(target, srs_type="epsg")
+    * The ``<ows:WGS84BoundingBox>`` element for ``GetCapabilities``.
+    * The ``<gml:Envelope>`` inside an``<gml:boundedBy>``  single feature.
 
-    return CoordTransform(source, target)
+    While both classes have no common base class (and exist in different schema's),
+    their properties are identical.
 
+    The X/Y coordinates can be either latitude or longitude, depending on the CRS.
 
-@dataclass(frozen=True)
-class CRS:
-    """
-    Represents a CRS (Coordinate Reference System), which preferably follows the URN format
-    as specified by `the OGC consortium <http://www.opengeospatial.org/ogcUrnPolicy>`_.
+    Note this isn't using the GDAL/OGR "Envelope" object, as that doesn't expose the CRS,
+    and requires constant copies to merge geometries.
     """
 
-    # CRS logic, based upon https://github.com/wglas85/django-wfs/blob/master/wfs/helpers.py
-    # Copyright (c) 2006 Wolfgang Glas - Apache 2.0 licensed
-    # Ported to Python 3.6 style.
-
-    #: Either "ogc" or "opengis", whereas "ogc" is highly recommended.
-    domain: str
-
-    #: Either "OGC" or "EPSG".
-    authority: str
-
-    #: The version of the authorities' SRS registry, which is empty or
-    #: contains two or three numeric components separated by dots like "6.9" or "6.11.9".
-    #: For WFS 2.0 this is typically empty.
-    version: str
-
-    #: A string representation of the coordinate system reference ID.
-    #: For OGC, only "CRS84" is supported as crsid. For EPSG, this is the formatted CRSID.
-    crsid: str
-
-    #: The integer representing the numeric spatial reference ID as
-    #: used by the EPSG and GIS database backends.
-    srid: int
-
-    #: GDAL SpatialReference with PROJ.4 / WKT content to describe the exact transformation.
-    backend: SpatialReference | None = None
-
-    #: Original input
-    origin: str = field(init=False, default=None)
-
-    has_custom_backend: bool = field(init=False)
-
-    def __post_init__(self):
-        # Using __dict__ because of frozen=True
-        self.__dict__["has_custom_backend"] = self.backend is not None
-
-    @classmethod
-    def from_string(cls, uri: str | int, backend: SpatialReference | None = None) -> CRS:
-        """
-        Parse an CRS (Coordinate Reference System) URI, which preferably follows the URN format
-        as specified by `the OGC consortium <http://www.opengeospatial.org/ogcUrnPolicy>`_
-        and construct a new CRS instance.
-
-        The value can be 3 things:
-
-        * A URI in OGC URN format.
-        * A legacy CRS URI ("epsg:<SRID>", or "http://www.opengis.net/...").
-        * A numeric SRID (which calls `from_srid()`)
-        """
-        if isinstance(uri, int) or uri.isdigit():
-            return cls.from_srid(int(uri), backend=backend)
-        elif uri.startswith("urn:"):
-            return cls._from_urn(uri, backend=backend)
-        else:
-            return cls._from_legacy(uri, backend=backend)
-
-    @classmethod
-    def from_srid(cls, srid: int, backend=None):
-        """Instantiate this class using a numeric spatial reference ID
-
-        This is logically identical to calling::
-
-            CRS.from_string("urn:ogc:def:crs:EPSG:6.9:<SRID>")
-        """
-        crs = cls(
-            domain="ogc",
-            authority="EPSG",
-            version="",
-            crsid=str(srid),
-            srid=int(srid),
-            backend=backend,
-        )
-        crs.__dict__["origin"] = srid
-        return crs
+    min_x: float
+    min_y: float
+    max_x: float
+    max_y: float
+    crs: CRS | None = None
 
     @classmethod
-    def _from_urn(cls, urn, backend=None):  # noqa: C901
-        """Instantiate this class using a URN format."""
-        urn_match = CRS_URN_REGEX.match(urn)
-        if not urn_match:
-            raise ExternalValueError(f"Unknown CRS URN [{urn}] specified: {CRS_URN_REGEX.pattern}")
-
-        domain = urn_match.group("domain")
-        authority = urn_match.group("authority").upper()
-
-        if domain not in ("ogc", "opengis"):
-            raise ExternalValueError(f"CRS URI [{urn}] contains unknown domain [{domain}]")
-
-        if authority == "EPSG":
-            crsid = urn_match.group("id")
-            try:
-                srid = int(crsid)
-            except ValueError:
-                raise ExternalValueError(
-                    f"CRS URI [{urn}] should contain a numeric SRID value."
-                ) from None
-        elif authority == "OGC":
-            # urn:ogc:def:crs:OGC::CRS84 has x/y ordering (longitude/latitude)
-            crsid = urn_match.group("id").upper()
-            if crsid != "CRS84":
-                raise ExternalValueError(f"OGC CRS URI from [{urn}] contains unknown id [{id}]")
-            srid = 4326
+    def from_geometries(cls, geometries: list[GEOSGeometry], crs: CRS) -> BoundingBox | None:
+        """Calculate the extent of a collection of geometries."""
+        if not geometries:
+            return None
+        elif len(geometries) == 1:
+            # Common case: feature has a single geometry
+            ogr_geometry = geometries[0].ogr
+            crs.apply_to(ogr_geometry, clone=False)
+            return cls(*ogr_geometry.extent, crs=crs)
         else:
-            raise ExternalValueError(f"CRS URI [{urn}] contains unknown authority [{authority}]")
+            # Feature has multiple geometries.
+            # Start with an obviously invalid bbox,
+            # which corrects at the first extend_to_geometry call.
+            result = cls(math.inf, math.inf, -math.inf, -math.inf, crs=crs)
 
-        crs = cls(
-            domain=domain,
-            authority=authority,
-            version=urn_match.group(3),
-            crsid=crsid,
-            srid=srid,
-            backend=backend,
-        )
-        crs.__dict__["origin"] = urn
-        return crs
-
-    @classmethod
-    def _from_legacy(cls, uri, backend=None):
-        """Instantiate this class from a legacy URL"""
-        luri = uri.lower()
-        for head in (
-            "epsg:",
-            "http://www.opengis.net/def/crs/epsg/0/",
-            "http://www.opengis.net/gml/srs/epsg.xml#",
-        ):
-            if luri.startswith(head):
-                crsid = luri[len(head) :]
-                try:
-                    srid = int(crsid)
-                except ValueError:
-                    raise ExternalValueError(
-                        f"CRS URI [{uri}] should contain a numeric SRID value."
-                    ) from None
-
-                crs = cls(
-                    domain="ogc",
-                    authority="EPSG",
-                    version="",
-                    crsid=crsid,
-                    srid=srid,
-                    backend=backend,
-                )
-                crs.__dict__["origin"] = uri
-                return crs
+            for geometry in geometries:
+                ogr_geometry = geometry.ogr
+                crs.apply_to(ogr_geometry, clone=False)
+                result.extend_to(*ogr_geometry.extent)
 
-        raise ExternalValueError(f"Unknown CRS URI [{uri}] specified")
-
-    @property
-    def legacy(self):
-        """Return a legacy string in the format "EPSG:<srid>"""
-        return f"EPSG:{self.srid:d}"
-
-    @cached_property
-    def urn(self):
-        """Return The OGC URN corresponding to this CRS."""
-        return f"urn:{self.domain}:def:crs:{self.authority}:{self.version or ''}:{self.crsid}"
-
-    def __str__(self):
-        return self.urn
-
-    def __eq__(self, other):
-        if isinstance(other, CRS):
-            # CRS84 is NOT equivalent to EPSG:4326.
-            # EPSG:4326 specifies coordinates in lat/long order and CRS84 in long/lat order.
-            return self.authority == other.authority and self.srid == other.srid
-        else:
-            return NotImplemented
-
-    def __hash__(self):
-        """Used to match objects in a set."""
-        return hash((self.authority, self.srid))
-
-    def _as_gdal(self) -> SpatialReference:
-        """Generate the GDAL Spatial Reference object"""
-        if self.backend is None:
-            # Avoid repeated construction, reuse the object from cache if possible.
-            # Note that the original data is used, as it also defines axis orientation.
-            if self.origin:
-                self.__dict__["backend"] = _get_spatial_reference(self.origin)
-            else:
-                self.__dict__["backend"] = _get_spatial_reference(self.srid, srs_type="epsg")
-        return self.backend
-
-    def apply_to(self, geometry: GEOSGeometry, clone=False) -> GEOSGeometry | None:
-        """Transform the geometry using this coordinate reference.
-
-        This method caches the used CoordTransform object
-
-        Every transformation within this package happens through this method,
-        giving full control over coordinate transformations.
-        """
-        if self.srid == geometry.srid:
-            # Avoid changes if spatial reference system is identical.
-            if clone:
-                return geometry.clone()
-            else:
-                return None
-        else:
-            # Convert using GDAL / proj
-            transform = _get_coord_transform(geometry.srid, self._as_gdal())
-            return geometry.transform(transform, clone=clone)
-
-
-# Worldwide GPS, latitude/longitude (y/x). https://epsg.io/4326
-WGS84 = CRS.from_string("urn:ogc:def:crs:EPSG::4326")
-
-# GeoJSON default. This is like WGS84 but with longitude/latitude (x/y).
-CRS84 = CRS.from_string("urn:ogc:def:crs:OGC::CRS84")
-
-#: Spherical Mercator (Google Maps, Bing Maps, OpenStreetMap, ...), see https://epsg.io/3857
-WEB_MERCATOR = CRS.from_string("urn:ogc:def:crs:EPSG::3857")
-
-
-@dataclass
-class BoundingBox:
-    """A bounding box (or "envelope") that describes the extent of a map layer"""
-
-    south: Decimal  # longitude
-    west: Decimal  # latitude
-    north: Decimal  # longitude
-    east: Decimal  # latitude
-    crs: CRS | None = None
-
-    @classmethod
-    def from_geometry(cls, geometry: GEOSGeometry, crs: CRS | None = None):
-        """Construct the bounding box for a geometry"""
-        if crs is None:
-            crs = CRS.from_srid(geometry.srid)
-        elif geometry.srid != crs.srid:
-            geometry = crs.apply_to(geometry, clone=True)
-
-        return cls(*geometry.extent, crs=crs)
+            return result
 
     @property
     def lower_corner(self):
-        return [self.south, self.west]
+        return [self.min_x, self.min_y]
 
     @property
     def upper_corner(self):
-        return [self.north, self.east]
+        return [self.max_x, self.max_y]
 
-    def __repr__(self):
-        return f"BoundingBox({self.south}, {self.west}, {self.north}, {self.east})"
-
-    def extend_to(self, lower_lon: float, lower_lat: float, upper_lon: float, upper_lat: float):
+    def extend_to(self, min_x: float, min_y: float, max_x: float, max_y: float):
         """Expand the bounding box in-place"""
-        self.south = min(self.south, lower_lon)
-        self.west = min(self.west, lower_lat)
-        self.north = max(self.north, upper_lon)
-        self.east = max(self.east, upper_lat)
-
-    def extend_to_geometry(self, geometry: GEOSGeometry):
-        """Extend this bounding box with the coordinates of a given geometry."""
-        if self.crs is not None and geometry.srid != self.crs.srid:
-            geometry = self.crs.apply_to(geometry, clone=True)
-
-        self.extend_to(*geometry.extent)
+        self.min_x = min(self.min_x, min_x)
+        self.min_y = min(self.min_y, min_y)
+        self.max_x = max(self.max_x, max_x)
+        self.max_y = max(self.max_y, max_y)
 
     def __add__(self, other):
         """Combine both extents into a larger box."""
@@ -343,11 +89,23 @@ class BoundingBox:
                 raise ValueError(
                     "Can't combine instances with different spatial reference systems"
                 )
-            return BoundingBox(
-                min(self.south, other.south),
-                min(self.west, other.west),
-                max(self.north, other.north),
-                max(self.east, other.east),
+            return self.__class__(
+                min(self.min_x, other.min_x),
+                min(self.min_y, other.min_y),
+                max(self.max_x, other.max_x),
+                max(self.max_y, other.max_y),
+                crs=self.crs,
             )
         else:
             return NotImplemented
+
+
+class WGS84BoundingBox(BoundingBox):
+    """The ``<ows:WGS84BoundingBox>`` element for the ``GetCapabilities`` element.
+
+    This always has coordinates are always in longitude/latitude axis ordering,
+    the CRS is fixed to ``urn:ogc:def:crs:OGC:2:84``.
+    """
+
+    def __init__(self, min_x: float, min_y: float, max_x: float, max_y: float):
+        super().__init__(min_x, min_y, max_x, max_y, crs=WGS84_BOUNDING_BOX_CRS)