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

gisserver/types.py

@@ -26,37 +26,35 @@ Custom field types could also generate these field types.
 
 from __future__ import annotations
 
+import logging
 import operator
 import re
 from dataclasses import dataclass, field
+from datetime import date, datetime, time, timedelta
 from decimal import Decimal as D
 from enum import Enum
 from functools import cached_property
-from typing import TYPE_CHECKING, Literal, cast
+from typing import TYPE_CHECKING, Literal
 
-from django.conf import settings
+import django
 from django.contrib.gis.db.models import F, GeometryField
+from django.contrib.gis.geos import GEOSGeometry
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import models
 from django.db.models import Q
-from django.db.models.fields.related import (  # Django 2 imports
-    ForeignObjectRel,
-    RelatedField,
-)
-from django.utils import dateparse
+from django.db.models.fields.related import RelatedField
 
+from gisserver.compat import ArrayField, GeneratedField
+from gisserver.crs import CRS
 from gisserver.exceptions import ExternalParsingError, OperationProcessingFailed
-from gisserver.geometries import CRS, WGS84  # noqa: F401 / for backwards compatibility
+from gisserver.geometries import BoundingBox
+from gisserver.parsers import values
+from gisserver.parsers.xml import parse_qname, split_ns, xmlns
 
-_unbounded = Literal["unbounded"]
-
-if "django.contrib.postgres" in settings.INSTALLED_APPS:
-    from django.contrib.postgres.fields import ArrayField
-else:
-    ArrayField = None
+logger = logging.getLogger(__name__)
 
 __all__ = [
-    "GmlElement",
+    "GeometryXsdElement",
     "GmlIdAttribute",
     "GmlNameElement",
     "ORMPath",
@@ -67,137 +65,140 @@ __all__ = [
     "XsdElement",
     "XsdNode",
     "XsdTypes",
-    "split_xml_name",
-    "FES20",
-    "GML21",
-    "GML32",
-    "XSI",
 ]
 
-GML21 = "http://www.opengis.net/gml"
-GML32 = "http://www.opengis.net/gml/3.2"
-XSI = "http://www.w3.org/2001/XMLSchema-instance"
-FES20 = "http://www.opengis.net/fes/2.0"
-
 RE_XPATH_ATTR = re.compile(r"\[[^\]]+\]$")  # match [@attr=..]
-TYPES_TO_PYTHON = {}
 
 
 class XsdAnyType:
-    """Base class for all types used in the XML definition"""
+    """Base class for all types used in the XML definition.
+    This includes the enum values (:class:`XsdTypes`) for well-known types,
+    adn the :class:`XsdComplexType` that represents a while class definition.
+    """
 
+    #: Local name of the XML element
     name: str
-    prefix = None
+
+    #: Namespace of the XML element
+    namespace = None
+
+    #: Whether this is a complex type
     is_complex_type = False
-    is_geometry = False
+
+    #: Whether this is a geometry
+    is_geometry = False  # Overwritten for some gml types.
 
     def __str__(self):
-        """Return the type name"""
+        """Return the type name (in full XML format)"""
         raise NotImplementedError()
 
-    def with_prefix(self, prefix="xs"):
-        xml_name = str(self)
-        if ":" in xml_name:
-            return xml_name
-        else:
-            return f"{prefix}:{xml_name}"
-
     def to_python(self, raw_value):
         """Convert a raw string value to this type representation"""
         return raw_value
 
 
 class XsdTypes(XsdAnyType, Enum):
-    """Brief enumeration of basic XMLSchema types.
+    """Brief enumeration of common XMLSchema types.
 
     The :class:`XsdElement` and :class:`XsdAttribute` can use these enum members
     to indicate their value is a well-known XML Schema. Some GML types are included as well.
 
-    The default namespace is the "xs:" (XMLSchema).
-    Based on https://www.w3.org/TR/xmlschema-2/#built-in-datatypes
+    Each member value is a fully qualified XML name.
+    The output rendering will convert these to the chosen prefixes.
     """
 
-    anyType = "anyType"  # Needs to be anyType, as "xsd:any" is an element, not a type.
-    string = "string"
-    boolean = "boolean"
-    decimal = "decimal"  # the base type for all numbers too.
-    integer = "integer"  # integer value
-    float = "float"
-    double = "double"
-    time = "time"
-    date = "date"
-    dateTime = "dateTime"
-    anyURI = "anyURI"
+    anyType = xmlns.xs.qname("anyType")  # not "xsd:any", that is an element.
+    string = xmlns.xs.qname("string")
+    boolean = xmlns.xs.qname("boolean")
+    decimal = xmlns.xs.qname("decimal")  # the base type for all numbers too.
+    integer = xmlns.xs.qname("integer")  # integer value
+    float = xmlns.xs.qname("float")
+    double = xmlns.xs.qname("double")
+    time = xmlns.xs.qname("time")
+    date = xmlns.xs.qname("date")
+    dateTime = xmlns.xs.qname("dateTime")
+    anyURI = xmlns.xs.qname("anyURI")
 
     # Number variations
-    byte = "byte"  # signed 8-bit integer
-    short = "short"  # signed 16-bit integer
-    int = "int"  # signed 32-bit integer
-    long = "long"  # signed 64-bit integer
-    unsignedByte = "unsignedByte"  # unsigned 8-bit integer
-    unsignedShort = "unsignedShort"  # unsigned 16-bit integer
-    unsignedInt = "unsignedInt"  # unsigned 32-bit integer
-    unsignedLong = "unsignedLong"  # unsigned 64-bit integer
+    byte = xmlns.xs.qname("byte")  # signed 8-bit integer
+    short = xmlns.xs.qname("short")  # signed 16-bit integer
+    int = xmlns.xs.qname("int")  # signed 32-bit integer
+    long = xmlns.xs.qname("long")  # signed 64-bit integer
+    unsignedByte = xmlns.xs.qname("unsignedByte")  # unsigned 8-bit integer
+    unsignedShort = xmlns.xs.qname("unsignedShort")  # unsigned 16-bit integer
+    unsignedInt = xmlns.xs.qname("unsignedInt")  # unsigned 32-bit integer
+    unsignedLong = xmlns.xs.qname("unsignedLong")  # unsigned 64-bit integer
 
     # Less common, but useful nonetheless:
-    duration = "duration"
-    nonNegativeInteger = "nonNegativeInteger"
-    gYear = "gYear"
-    hexBinary = "hexBinary"
-    base64Binary = "base64Binary"
-    token = "token"  # noqa: S105
-    language = "language"
+    duration = xmlns.xs.qname("duration")
+    nonNegativeInteger = xmlns.xs.qname("nonNegativeInteger")
+    gYear = xmlns.xs.qname("gYear")
+    hexBinary = xmlns.xs.qname("hexBinary")
+    base64Binary = xmlns.xs.qname("base64Binary")
+    token = xmlns.xs.qname("token")  # noqa: S105
+    language = xmlns.xs.qname("language")
 
     # Types that contain a GML value as member:
-    gmlGeometryPropertyType = "gml:GeometryPropertyType"
-    gmlPointPropertyType = "gml:PointPropertyType"
-    gmlCurvePropertyType = "gml:CurvePropertyType"  # curve is base for LineString
-    gmlSurfacePropertyType = "gml:SurfacePropertyType"  # GML2 had PolygonPropertyType
-    gmlMultiSurfacePropertyType = "gml:MultiSurfacePropertyType"
-    gmlMultiPointPropertyType = "gml:MultiPointPropertyType"
-    gmlMultiCurvePropertyType = "gml:MultiCurvePropertyType"
-    gmlMultiGeometryPropertyType = "gml:MultiGeometryPropertyType"
-
-    # Other typical GML values
-    gmlCodeType = "gml:CodeType"  # for <gml:name>
-    gmlBoundingShapeType = "gml:BoundingShapeType"  # for <gml:boundedBy>
-
-    #: A direct geometry value (used as function argument type)
-    gmlAbstractGeometryType = "gml:AbstractGeometryType"
+    # Note these receive the "is_geometry = True" value below.
+    gmlGeometryPropertyType = xmlns.gml.qname("GeometryPropertyType")
+    gmlPointPropertyType = xmlns.gml.qname("PointPropertyType")
+    gmlCurvePropertyType = xmlns.gml.qname("CurvePropertyType")  # curve is base for LineString
+    gmlSurfacePropertyType = xmlns.gml.qname("SurfacePropertyType")  # GML2 had PolygonPropertyType
+    gmlMultiSurfacePropertyType = xmlns.gml.qname("MultiSurfacePropertyType")
+    gmlMultiPointPropertyType = xmlns.gml.qname("MultiPointPropertyType")
+    gmlMultiCurvePropertyType = xmlns.gml.qname("MultiCurvePropertyType")
+    gmlMultiGeometryPropertyType = xmlns.gml.qname("MultiGeometryPropertyType")
+
+    # Other typical GML values:
+
+    #: The type for ``<gml:name>`` elements.
+    gmlCodeType = xmlns.gml.qname("CodeType")  # for <gml:name>
+
+    #: The type for ``<gml:boundedBy>`` elements.
+    gmlBoundingShapeType = xmlns.gml.qname("BoundingShapeType")
+
+    #: The type for ``<gml:Envelope>`` elements, sometimes used as function argument type.
+    gmlEnvelopeType = xmlns.gml.qname("EnvelopeType")
+
+    #: A direct geometry value, sometimes used as function argument type.
+    gmlAbstractGeometryType = xmlns.gml.qname("AbstractGeometryType")
 
     #: A feature that has a gml:name and gml:boundedBy as possible child element.
-    gmlAbstractFeatureType = "gml:AbstractFeatureType"
-    gmlAbstractGMLType = "gml:AbstractGMLType"  # base class of gml:AbstractFeatureType
+    gmlAbstractFeatureType = xmlns.gml.qname("AbstractFeatureType")
+
+    #: The base of gml:AbstractFeatureType
+    gmlAbstractGMLType = xmlns.gml.qname("AbstractGMLType")
 
     def __str__(self):
         return self.value
 
-    @property
-    def prefix(self) -> str | None:
-        """Extrapolate the prefix from the type name"""
-        xml_name = str(self)
-        colon = xml_name.find(":")
-        return xml_name[:colon] if colon else None
+    def __init__(self, value):
+        # Parse XML namespace data once, which to_qname() uses.
+        # Can't set enum.name, so will use a property for that.
+        self.namespace, self._localname = split_ns(value)
+        self.is_geometry = False  # redefined below
 
     @cached_property
-    def is_geometry(self):
-        """Whether the value represents an element which contains a GML element."""
-        return self.prefix == "gml" and self.value.endswith("PropertyType")
+    def name(self) -> str:
+        """Overwrites enum.name to return the XML local name.
+        This is used for to_qname().
+        """
+        return self._localname
 
     @cached_property
     def _to_python_func(self):
-        if not TYPES_TO_PYTHON:
-            _init_types_to_python()
-
         try:
             return TYPES_TO_PYTHON[self]
         except KeyError:
             raise NotImplementedError(f'Casting to "{self}" is not implemented.') from None
 
     def to_python(self, raw_value):
-        """Convert a raw string value to this type representation"""
-        if self.is_geometry:
-            # Leave complex values as-is.
+        """Convert a raw string value to this type representation.
+
+        :raises ExternalParsingError: When the value can't be converted to the proper type.
+        """
+        if self.is_geometry or isinstance(raw_value, TYPES_AS_PYTHON[self]):
+            # Detect when the value was already parsed, no need to reparse a date for example.
             return raw_value
 
         try:
@@ -206,40 +207,73 @@ class XsdTypes(XsdAnyType, Enum):
             raise  # subclass of ValueError so explicitly caught and reraised
         except (TypeError, ValueError, ArithmeticError) as e:
             # ArithmeticError is base of DecimalException
-            raise ExternalParsingError(f"Can't cast '{raw_value}' to {self}.") from e
-
-
-def _init_types_to_python():
-    """Define how well-known scalar types are parsed into python
-    (mimicking Django's to_python()):
-    """
-    global TYPES_TO_PYTHON
-    from gisserver.parsers import values  # avoid cyclic import
-
-    def as_is(v):
-        return v
-
-    TYPES_TO_PYTHON = {
-        XsdTypes.date: dateparse.parse_date,
-        XsdTypes.dateTime: values.parse_iso_datetime,
-        XsdTypes.time: dateparse.parse_time,
-        XsdTypes.string: as_is,
-        XsdTypes.boolean: values.parse_bool,
-        XsdTypes.integer: int,
-        XsdTypes.int: int,
-        XsdTypes.long: int,
-        XsdTypes.short: int,
-        XsdTypes.byte: int,
-        XsdTypes.unsignedInt: int,
-        XsdTypes.unsignedLong: int,
-        XsdTypes.unsignedShort: int,
-        XsdTypes.unsignedByte: int,
-        XsdTypes.float: D,
-        XsdTypes.double: D,
-        XsdTypes.decimal: D,
-        XsdTypes.gmlCodeType: as_is,
-        XsdTypes.anyType: values.auto_cast,
-    }
+            logger.debug("Parsing error for %r: %s", raw_value, e)
+            name = self.name if self.namespace == xmlns.xsd.value else self.value
+            raise ExternalParsingError(f"Can't cast '{raw_value}' to {name}.") from e
+
+
+for _type in (
+    XsdTypes.gmlGeometryPropertyType,
+    XsdTypes.gmlPointPropertyType,
+    XsdTypes.gmlCurvePropertyType,
+    XsdTypes.gmlSurfacePropertyType,
+    XsdTypes.gmlMultiSurfacePropertyType,
+    XsdTypes.gmlMultiPointPropertyType,
+    XsdTypes.gmlMultiCurvePropertyType,
+    XsdTypes.gmlMultiGeometryPropertyType,
+    # gml:boundedBy is technically a geometry, which we don't support in queries currently.
+    XsdTypes.gmlBoundingShapeType,
+):
+    # One of the reasons the code checks for "xsd_element.type.is_geometry"
+    # is because profiling showed that isinstance(xsd_element, ...) is really slow.
+    # When rendering 5000 objects with 10+ elements, isinstance() started showing up as hotspot.
+    _type.is_geometry = True
+
+
+def _as_is(v):
+    return v
+
+
+TYPES_AS_PYTHON = {
+    XsdTypes.date: date,
+    XsdTypes.dateTime: datetime,
+    XsdTypes.time: time,
+    XsdTypes.string: str,
+    XsdTypes.boolean: bool,
+    XsdTypes.integer: int,
+    XsdTypes.int: int,
+    XsdTypes.long: int,
+    XsdTypes.short: int,
+    XsdTypes.byte: int,
+    XsdTypes.unsignedInt: int,
+    XsdTypes.unsignedLong: int,
+    XsdTypes.unsignedShort: int,
+    XsdTypes.unsignedByte: int,
+    XsdTypes.float: D,  # auto_cast() always converts to decimal
+    XsdTypes.double: D,
+    XsdTypes.decimal: D,
+    XsdTypes.duration: timedelta,
+    XsdTypes.nonNegativeInteger: int,
+    XsdTypes.gYear: int,
+    XsdTypes.hexBinary: bytes,
+    XsdTypes.base64Binary: bytes,
+    XsdTypes.token: str,
+    XsdTypes.language: str,
+    XsdTypes.gmlCodeType: str,
+    XsdTypes.anyType: type(Ellipsis),
+}
+
+TYPES_TO_PYTHON = {
+    **TYPES_AS_PYTHON,
+    XsdTypes.date: values.parse_iso_date,
+    XsdTypes.dateTime: values.parse_iso_datetime,
+    XsdTypes.time: values.parse_iso_time,
+    XsdTypes.string: _as_is,
+    XsdTypes.boolean: values.parse_bool,
+    XsdTypes.duration: values.parse_iso_duration,
+    XsdTypes.gmlCodeType: _as_is,
+    XsdTypes.anyType: values.auto_cast,
+}
 
 
 class XsdNode:
@@ -250,22 +284,29 @@ class XsdNode:
     parse query input and read model attributes to write as output.
     """
 
+    #: Whether this node is an :class:`XsdAttribute` (avoids slow ``isinstance()`` checks)
     is_attribute = False
+    #: Whether this node can occur multiple times.
     is_many = False
 
+    #: The local name of the XML element
     name: str
-    type: XsdAnyType  # Both XsdComplexType and XsdType are allowed
-    prefix: str | None
+
+    #: The data type of the element/attribute, both :class:`XsdComplexType` and :class:`XsdTypes` are allowed.
+    type: XsdAnyType
+
+    #: XML Namespace of the element
+    namespace: xmlns | str | None
 
     #: Which field to read from the model to get the value
     #: This supports dot notation to access related attributes.
-    source: models.Field | ForeignObjectRel | None
+    source: models.Field | models.ForeignObjectRel | None
 
     #: Which field to read from the model to get the value
     #: This supports dot notation to access related attributes.
     model_attribute: str | None
 
-    #: A link back to the parent that described the featuyre this node is a part of.
+    #: A link back to the parent that described the feature this node is a part of.
     #: This helps to perform additional filtering in side meth:get_value: based on user policies.
     feature_type: FeatureType | None
 
@@ -273,24 +314,49 @@ class XsdNode:
         self,
         name: str,
         type: XsdAnyType,
+        namespace: xmlns | str | None,
         *,
-        prefix: str | None = "app",
-        source: models.Field | ForeignObjectRel | None = None,
+        source: models.Field | models.ForeignObjectRel | None = None,
         model_attribute: str | None = None,
+        absolute_model_attribute: str | None = None,
         feature_type: FeatureType | None = None,
     ):
+        """
+        :param name: The local name of the element.
+        :param type: The XML Schema type of the element, can also be a XsdComplexType.
+        :param namespace: XML namespace URI.
+        :param source: Original Model field, which can provide more metadata/parsing.
+        :param model_attribute: The Django model path that this element accesses.
+        :param absolute_model_attribute: The full path, including parent elements.
+        :param feature_type: Typically assigned in :meth:`~gisserver.features.FeatureField.bind`,
+                             needed by some :meth:`get_value` functions.
+        """
+        if ":" in name:
+            raise ValueError(
+                "XsdNode should receive the localname, not the QName in ns:localname format."
+            )
+        elif "}" in name:
+            raise ValueError(
+                "XsdNode should receive the localname, not the full name in {uri}name format."
+            )
+
         # Using plain assignment instead of dataclass turns out to be needed
         # for flexibility and easier subclassing.
         self.name = name
         self.type = type
-        self.prefix = prefix
+        self.namespace = str(namespace) if namespace is not None else None  # cast enum members.
         self.source = source
         self.model_attribute = model_attribute or self.name
-        # link back to parent, some get_value() functions need it.
+        self.absolute_model_attribute = absolute_model_attribute or self.model_attribute
+        # link back to top-level parent, some get_value() functions need it.
         self.feature_type = feature_type
 
-        if ":" in self.name:
-            raise ValueError("Use 'prefix' argument for namespaces")
+        if (
+            self.model_attribute
+            and self.absolute_model_attribute
+            and not self.absolute_model_attribute.endswith(self.model_attribute)
+        ):
+            raise ValueError("Inconsistent 'absolute_model_attribute' and 'model_attribute' value")
 
         self._attrgetter = operator.attrgetter(self.model_attribute)
         self._valuegetter = self._build_valuegetter(self.model_attribute, self.source)
@@ -304,7 +370,7 @@ class XsdNode:
     @staticmethod
     def _build_valuegetter(
         model_attribute: str,
-        field: models.Field | ForeignObjectRel | None,
+        field: models.Field | models.ForeignObjectRel | None,
     ):
         """Select the most efficient read function to retrieves the value.
 
@@ -314,7 +380,7 @@ class XsdNode:
         since this will be much faster than using ``getattr()``.
         The custom ``value_from_object()`` is fully supported too.
         """
-        if field is None or isinstance(field, ForeignObjectRel):
+        if field is None or isinstance(field, models.ForeignObjectRel):
             # No model field, can only use getattr(). The attrgetter() function is both faster,
             # and has built-in support for traversing model attributes with dots.
             return operator.attrgetter(model_attribute)
@@ -341,11 +407,6 @@ class XsdNode:
 
         return _related_get_value_from_object
 
-    @cached_property
-    def is_geometry(self) -> bool:
-        """Tell whether the XML node/element should be handed as GML geometry."""
-        return self.type.is_geometry or isinstance(self.source, GeometryField)
-
     @cached_property
     def is_array(self) -> bool:
         """Tell whether this node is backed by an PostgreSQL Array Field."""
@@ -359,33 +420,48 @@ class XsdNode:
     @cached_property
     def xml_name(self):
         """The XML element/attribute name."""
-        return f"{self.prefix}:{self.name}" if self.prefix else self.name
+        return f"{{{self.namespace}}}{self.name}" if self.namespace else self.name
+
+    def relative_orm_path(self, parent: XsdElement | None = None) -> str:
+        """The ORM field lookup to perform, relative to the parent element."""
+        if parent is None:
+            return self.orm_path
+
+        prefix = f"{parent.orm_path}__"
+        if not self.orm_path.startswith(prefix):
+            raise ValueError(f"Node '{self}' is not a child of '{parent}.")
+        else:
+            return self.orm_path[len(prefix) :]
 
     @cached_property
-    def orm_path(self) -> str:
+    def local_orm_path(self) -> str:
         """The ORM field lookup to perform."""
         if self.model_attribute is None:
             raise ValueError(f"Node {self.xml_name} has no 'model_attribute' set.")
         return self.model_attribute.replace(".", "__")
 
+    @cached_property
+    def orm_path(self) -> str:
+        """The ORM field lookup to perform."""
+        if self.absolute_model_attribute is None:
+            raise ValueError(f"Node {self.xml_name} has no 'absolute_model_attribute' set.")
+        return self.absolute_model_attribute.replace(".", "__")
+
     @cached_property
     def orm_field(self) -> str:
-        """The direct ORM field that provides this property."""
-        if self.model_attribute is None:
-            raise ValueError(f"Node {self.xml_name} has no 'model_attribute' set.")
-        return self.model_attribute.partition(".")[0]
+        """The direct ORM field that provides this property; the first relative level.
+        Typically, this is the same as the field name.
+        """
+        return self.orm_path.partition(".")[0]
 
     @cached_property
     def orm_relation(self) -> tuple[str | None, str]:
-        """The ORM field and parent relation"""
-        if self.model_attribute is None:
-            raise ValueError(f"Node {self.xml_name} has no 'model_attribute' set.")
-
-        path, _, field = self.model_attribute.rpartition(".")
-        if not path:
-            return None, field
-        else:
-            return path.replace(".", "__"), field
+        """The ORM field and parent relation.
+        Note this isn't something like "self.parent.orm_path",
+        as this mode may have a dotted-path to its source attribute.
+        """
+        path, _, field = self.orm_path.rpartition("__")
+        return path or None, field
 
     def build_lhs_part(self, compiler: CompiledQuery, match: ORMPath):
         """Give the ORM part when this element is used as left-hand-side of a comparison.
@@ -427,13 +503,10 @@ class XsdNode:
         """
         return value
 
-    @cached_property
-    def _form_field(self):
-        """Internal cached field for to_python()"""
-        return self.source.formfield()
-
     def to_python(self, raw_value: str):
-        """Convert a raw value to the Python data type for this element type."""
+        """Convert a raw value to the Python data type for this element type.
+        :raises ValidationError: When the value isn't allowed for the field type.
+        """
         try:
             raw_value = self.type.to_python(raw_value)
             if self.source is not None:
@@ -454,24 +527,39 @@ class XsdNode:
 
         The raw string value can be passed here. Auto-cased values could
         raise an TypeError due to being unsupported by the validation.
+
+        :param raw_value: The string value taken from the XML node.
+        :param lookup: The ORM lookup (e.g. ``equals`` or ``fes_like``).
+        :param tag: The filter operator tag name, e.g. ``PropertyIsEqualTo``.
+        :returns: The parsed Python value.
         """
-        if self.source is not None:
-            # Not calling self.source.validate() as that checks for allowed choices,
-            # which shouldn't be checked against for a filter query.
-            raw_value = self.to_python(raw_value)
-
-            # Check whether the Django model field supports the lookup
-            # This prevents calling LIKE on a datetime or float field.
-            # For foreign keys, this depends on the target field type.
-            if self.source.get_lookup(lookup) is None or (
+        # Not calling self.source.validate() as that checks for allowed choices,
+        # which shouldn't be checked against for a filter query.
+        raw_value = self.to_python(raw_value)
+
+        # Check whether the Django model field supports the lookup
+        # This prevents calling LIKE on a datetime or float field.
+        # For foreign keys, this depends on the target field type.
+        if (
+            self.source is not None
+            and self.source.get_lookup(lookup) is None
+            or (
                 isinstance(self.source, RelatedField)
                 and self.source.target_field.get_lookup(lookup) is None
-            ):
-                raise OperationProcessingFailed(
-                    f"Operator '{tag}' is not supported for the '{self.name}' property.",
-                    locator="filter",
-                    status_code=400,  # not HTTP 500 here. Spec allows both.
-                )
+            )
+        ):
+            logger.debug(
+                "Model field '%s.%s' does not support ORM lookup '%s' used by '%s'.",
+                self.feature_type.model._meta.model_name,
+                self.absolute_model_attribute,
+                lookup,
+                tag,
+            )
+            raise OperationProcessingFailed(
+                f"Operator '{tag}' is not supported for the '{self.name}' property.",
+                locator="filter",
+                status_code=400,  # not HTTP 500 here. Spec allows both.
+            )
 
         return raw_value
 
@@ -484,60 +572,49 @@ class XsdElement(XsdNode):
     This holds the definition for a single property in the WFS server.
     It's used in ``DescribeFeatureType`` to output the field metadata,
     and used in ``GetFeature`` to access the actual value from the object.
-    Overriding :meth:`get_value` allows to override this logic.
+    Overriding :meth:`XsdNode.get_value` allows to override this logic.
 
-    The :attr:`name` may differ from the underlying :attr:`model_attribute`,
+    The :attr:`name` may differ from the underlying :attr:`XsdNode.model_attribute`,
     so the WFS server can use other field names then the underlying model.
 
-    A dotted-path notation can be used for :attr:`model_attribute` to access
+    A dotted-path notation can be used for :attr:`XsdNode.model_attribute` to access
     a related field. For the WFS client, the data appears to be flattened.
     """
 
+    #: Whether the element can be null
     nillable: bool | None
+    #: The minimal number of times the element occurs in the output.
     min_occurs: int | None
-    max_occurs: int | _unbounded | None
+    #: The maximum number of times this element occurs in the output.
+    max_occurs: int | Literal["unbounded"] | None
 
     def __init__(
         self,
         name: str,
         type: XsdAnyType,
+        namespace: xmlns | str | None,
         *,
-        prefix: str | None = "app",
         nillable: bool | None = None,
         min_occurs: int | None = None,
-        max_occurs: int | _unbounded | None = None,
-        source: models.Field | ForeignObjectRel | None = None,
+        max_occurs: int | Literal["unbounded"] | None = None,
+        source: models.Field | models.ForeignObjectRel | None = None,
         model_attribute: str | None = None,
+        absolute_model_attribute: str | None = None,
         feature_type: FeatureType | None = None,
     ):
         super().__init__(
             name,
             type,
-            prefix=prefix,
+            namespace=namespace,
             source=source,
             model_attribute=model_attribute,
+            absolute_model_attribute=absolute_model_attribute,
             feature_type=feature_type,
         )
         self.nillable = nillable
         self.min_occurs = min_occurs
         self.max_occurs = max_occurs
 
-    @cached_property
-    def as_xml(self):
-        attributes = [f'name="{self.name}" type="{self.type}"']
-        if self.min_occurs is not None:
-            attributes.append(f'minOccurs="{self.min_occurs}"')
-        if self.max_occurs is not None:
-            attributes.append(f'maxOccurs="{self.max_occurs}"')
-        if self.nillable:
-            str_bool = "true" if self.nillable else "false"
-            attributes.append(f'nillable="{str_bool}"')
-
-        return "<element {} />".format(" ".join(attributes))
-
-    def __str__(self):
-        return self.as_xml
-
     @cached_property
     def is_many(self) -> bool:
         """Tell whether the XML element can be rendered multiple times.
@@ -577,35 +654,61 @@ class XsdAttribute(XsdNode):
         name: str,
         type: XsdAnyType = XsdTypes.string,  # added default
         *,
-        prefix: str | None = "app",
+        namespace: xmlns | str | None = None,
         use: str = "optional",
-        source: models.Field | ForeignObjectRel | None = None,
+        source: models.Field | models.ForeignObjectRel | None = None,
         model_attribute: str | None = None,
+        absolute_model_attribute: str | None = None,
         feature_type: FeatureType | None = None,
     ):
         super().__init__(
             name,
             type,
-            prefix=prefix,
+            namespace=namespace,
             source=source,
             model_attribute=model_attribute,
+            absolute_model_attribute=absolute_model_attribute,
             feature_type=feature_type,
         )
         self.use = use
 
 
-class GmlElement(XsdElement):
-    """Essentially the same as an XsdElement, but guarantee it returns a GeoDjango model field.
+class GeometryXsdElement(XsdElement):
+    """A subtype for the :class:`XsdElement` that provides access to geometry data.
+
+    This declares an element such as::
+
+        <app:geometry>
+            <gml:Point>...</gml:Point>
+        </app:geometry>
 
-    This only exists as "protocol" for the type annotations.
+    Hence, the :attr:`namespace` of this element isn't the GML namespace,
+    only the type it points to is geometry data.
+
+    The :attr:`source` is guaranteed to point to a :class:`~django.contrib.gis.models.GeometryField`,
+    and can be a :class:`~django.db.models.GeneratedField` in Django 5
+    as long as its ``output_field`` points to a :class:`~django.contrib.gis.models.GeometryField`.
     """
 
-    source: GeometryField
+    if django.VERSION >= (5, 0):
+        source: GeometryField | models.GeneratedField
+    else:
+        source: GeometryField
+
+    @cached_property
+    def source_srid(self) -> int:
+        """Tell which Spatial Reference Identifier the source information is stored under."""
+        if GeneratedField is not None and isinstance(self.source, GeneratedField):
+            # Allow GeometryField to be wrapped as:
+            # models.GeneratedField(SomeFunction("geofield"), output_field=models.GeometryField())
+            return self.source.output_field.srid
+        else:
+            return self.source.srid
 
 
 class GmlIdAttribute(XsdAttribute):
-    """A virtual 'gml:id' attribute that can be queried.
-    This subclass has overwritten get_value() logic to format the value.
+    """A virtual ``gml:id="..."`` attribute that can be queried.
+    This subclass has overwritten :meth:`get_value` logic to format the value.
     """
 
     type_name: str
@@ -613,20 +716,23 @@ class GmlIdAttribute(XsdAttribute):
     def __init__(
         self,
         type_name: str,
-        source: models.Field | ForeignObjectRel | None = None,
+        source: models.Field | models.ForeignObjectRel | None = None,
         model_attribute="pk",
+        absolute_model_attribute=None,
         feature_type: FeatureType | None = None,
     ):
         super().__init__(
-            prefix="gml",
             name="id",
+            namespace=xmlns.gml,
             source=source,
             model_attribute=model_attribute,
+            absolute_model_attribute=absolute_model_attribute,
             feature_type=feature_type,
         )
         object.__setattr__(self, "type_name", type_name)
 
     def get_value(self, instance: models.Model):
+        """Render the value."""
         pk = super().get_value(instance)  # handle dotted-name notations
         return f"{self.type_name}.{pk}"
 
@@ -636,7 +742,7 @@ class GmlIdAttribute(XsdAttribute):
 
 
 class GmlNameElement(XsdElement):
-    """A subclass to handle the <gml:name> element.
+    """A subclass to handle the ``<gml:name>`` element.
     This displays a human-readable title for the object.
 
     Currently, this just reads a single attribute,
@@ -644,19 +750,17 @@ class GmlNameElement(XsdElement):
     (although that would make comparisons on ``element@gml:name`` more complex).
     """
 
-    is_geometry = False  # Override type
-
     def __init__(
         self,
         model_attribute: str,
-        source: models.Field | ForeignObjectRel | None = None,
+        source: models.Field | models.ForeignObjectRel | None = None,
         feature_type=None,
     ):
         # Prefill most known fields
         super().__init__(
-            prefix="gml",
             name="name",
             type=XsdTypes.gmlCodeType,
+            namespace=xmlns.gml,
             min_occurs=0,
             source=source,
             model_attribute=model_attribute,
@@ -674,21 +778,19 @@ class GmlNameElement(XsdElement):
 
 
 class GmlBoundedByElement(XsdElement):
-    """A subclass to handle the <gml:boundedBy> element.
+    """A subclass to handle the ``<gml:boundedBy>`` element.
 
     This override makes sure this non-model element data
     can be included in the XML tree like every other element.
     Its value is the complete bounding box of the feature type data.
     """
 
-    is_geometry = True  # Override type
-
     def __init__(self, feature_type):
         # Prefill most known fields
         super().__init__(
-            prefix="gml",
             name="boundedBy",
             type=XsdTypes.gmlBoundingShapeType,
+            namespace=xmlns.gml,
             min_occurs=0,
             feature_type=feature_type,
         )
@@ -703,70 +805,125 @@ class GmlBoundedByElement(XsdElement):
         """Give the ORM part when this element would be used as right-hand-side"""
         raise NotImplementedError("queries against <gml:boundedBy> are not supported")
 
-    def get_value(self, instance: models.Model, crs: CRS | None = None):
-        """Provide the value of the <gml:boundedBy> field
-        (if this is not given by the database already)."""
-        return self.feature_type.get_envelope(instance, crs=crs)
+    def get_value(self, instance: models.Model, crs: CRS | None = None) -> BoundingBox | None:
+        """Provide the value of the <gml:boundedBy> field,
+        which is the bounding box for a single instance.
+
+        This is only used for native Python rendering. When the database
+        rendering is enabled (GISSERVER_USE_DB_RENDERING=True), the calculation
+        is entirely performed within the query.
+        """
+        geometries: list[GEOSGeometry] = list(
+            # remove 'None' values
+            filter(
+                None,
+                [
+                    # support dotted paths here for geometries in a foreign key relation.
+                    operator.attrgetter(geo_element.absolute_model_attribute)(instance)
+                    for geo_element in self.feature_type.all_geometry_elements
+                ],
+            )
+        )
+        if not geometries:
+            return None
+
+        return BoundingBox.from_geometries(geometries, crs)
 
 
 @dataclass(frozen=True)
 class XsdComplexType(XsdAnyType):
-    """Define an <xsd:complexType> that represents a whole class definition.
+    """Define an ``<xsd:complexType>`` that represents a whole class definition.
 
     Typically, this maps into a Django model, with each element pointing to a model field.
+    For example:
+
+    .. code-block:: python
+
+        XsdComplexType(
+            "PersonType",
+            elements=[
+                XsdElement("name", type=XsdTypes.string),
+                XsdElement("age", type=XsdTypes.integer),
+                XsdElement("address", type=XsdComplexType(
+                    "AddressType",
+                    elements=[
+                        XsdElement("street", type=XsdTypes.string),
+                        ...
+                    ]
+                )),
+            ],
+            attributes=[
+                XsdAttribute("id", type=XsdTypes.integer),
+            ],
+        )
 
     A complex type can hold multiple :class:`XsdElement` and :class:`XsdAttribute`
-    nodes as children, composing an object. The elements themselves can point
-    to a complex type themselves, to create a nested class structure.
+    nodes as children, composing an object. Its :attr:`base` may point to a :class:`XsdComplexType`
+    as base class, allowing to define those inherited elements too.
+
+    Each element can be a complex type themselves, to create a nested class structure.
     That also allows embedding models with their relations into a single response.
 
-    This object definition is the internal "source of truth" regarding
-    which field names and field elements are used in the WFS server.
-    The ``DescribeFeatureType`` request uses this definition to render the matching XMLSchema.
-    Incoming XPath queries are parsed using this object to resolve the XPath to model attributes.
+    .. note:: Good to know
+        This object definition is the internal "source of truth" regarding
+        which field names and field elements are used in the WFS server:
 
-    Objects of this type are typically generated by the ``FeatureType`` and
-    ``ComplexFeatureField`` classes, using the Django model data.
+        * The ``DescribeFeatureType`` request uses this definition to render the matching XMLSchema.
+        * Incoming XPath queries are parsed using this object to resolve the XPath to model attributes.
 
-    By default, The type is declared as subclass of <gml:AbstractFeatureType>,
-    which allows child elements like <gml:name> and <gml:boundedBy>.
+    Objects of this type are typically generated by the :class:`~gisserver.features.FeatureType` and
+    :class:`~gisserver.features.ComplexFeatureField` classes, using the Django model data.
+
+    By default, The :attr:`base` type is detected as ``<gml:AbstractFeatureType>``,
+    when there is a geometry element in the definition.
     """
 
-    #: Internal class name (without XML prefix)
+    #: Internal class name (without XML namespace/prefix)
     name: str
 
-    #: All elements in this class
-    elements: list[XsdElement]
+    #: The XML namespace
+    namespace: str | None
+
+    #: All local elements in this class
+    elements: list[XsdElement] = field(default_factory=list)
 
     #: All attributes in this class
     attributes: list[XsdAttribute] = field(default_factory=list)
 
     #: The base class of this type. Typically gml:AbstractFeatureType,
     #: which provides the <gml:name> and <gml:boundedBy> elements.
-    base: XsdAnyType = XsdTypes.gmlAbstractFeatureType
-
-    #: The prefix alias to use for the namespace.
-    prefix: str = "app"
+    base: XsdAnyType | None = None
 
     #: The Django model class that this type was based on.
     source: type[models.Model] | None = None
 
+    def __post_init__(self):
+        # Autodetect (or autocorrect) to have the proper base class when gml elements are present.
+        if self.base is None:
+            if any(e.type.is_geometry for e in self.elements):
+                # for <gml:name> and <gml:boundedBy> elements.
+                self.__dict__["base"] = XsdTypes.gmlAbstractFeatureType
+            elif any(e.type is XsdTypes.gmlCodeType for e in self.elements):
+                # for <gml:name> only
+                self.__dict__["base"] = XsdTypes.gmlAbstractGMLType
+
     def __str__(self):
         return self.xml_name
 
     @cached_property
     def xml_name(self):
-        """Name in the XMLSchema (e.g. app:SomeClass)."""
-        return f"{self.prefix}:{self.name}"
+        """Name in the XMLSchema (e.g. {http://example.org/namespace}:SomeClass)."""
+        return f"{{{self.namespace}}}{self.name}" if self.namespace else self.name
 
     @property
-    def is_complex_type(self):
+    def is_complex_type(self) -> bool:
+        """Always indicates this is a complex type."""
         return True  # a property to avoid being used as field.
 
     @cached_property
-    def all_elements(self) -> list[XsdElement]:
-        """All elements, including inherited elements."""
-        if self.base.is_complex_type:
+    def elements_including_base(self) -> list[XsdElement]:
+        """The local and inherited elements of this XSD type."""
+        if self.base is not None and self.base.is_complex_type:
             # Add all base class members, in their correct ordering
             # By having these as XsdElement objects instead of hard-coded writes,
             # the query/filter logic also works for these elements.
@@ -775,35 +932,35 @@ class XsdComplexType(XsdAnyType):
             return self.elements
 
     @cached_property
-    def geometry_elements(self) -> list[GmlElement]:
+    def geometry_elements(self) -> list[GeometryXsdElement]:
         """Shortcut to get all geometry elements"""
-        return [e for e in self.elements if e.is_geometry]
+        return [e for e in self.elements if e.type.is_geometry]
 
     @cached_property
     def complex_elements(self) -> list[_XsdElement_WithComplexType]:
-        """Shortcut to get all elements with a complex type"""
+        """Shortcut to get all elements with a complex type.
+        To get all complex elements recursively, read :attr:`all_complex_elements`.
+        """
         return [e for e in self.elements if e.type.is_complex_type]
 
     @cached_property
     def flattened_elements(self) -> list[XsdElement]:
-        """Shortcut to get all elements with a flattened model attribite"""
+        """Shortcut to get all elements with a flattened model attribute"""
         return [e for e in self.elements if e.is_flattened]
 
     @cached_property
-    def elements_with_children(self) -> dict[_XsdElement_WithComplexType, list[XsdElement]]:
+    def all_complex_elements(self) -> list[_XsdElement_WithComplexType]:
         """Shortcut to get all elements with children.
         This mainly exists to provide a structure to mimic what's used
         when PROPERTYNAME is part of the request.
         """
-        child_nodes = {}
-        for xsd_element in self.elements:
-            if xsd_element.type.is_complex_type:
-                sub_type = cast(XsdComplexType, xsd_element.type)
-                child_nodes[xsd_element] = sub_type.elements
-                child_nodes.update(sub_type.elements_with_children)
+        child_nodes = []
+        for xsd_element in self.complex_elements:
+            child_nodes.append(xsd_element)
+            child_nodes.extend(xsd_element.type.all_complex_elements)
         return child_nodes
 
-    def resolve_element_path(self, xpath: str) -> list[XsdNode] | None:
+    def resolve_element_path(self, xpath: str, ns_aliases: dict[str, str]) -> list[XsdNode] | None:
         """Resolve a xpath reference to the actual node.
         This returns the whole path, including in-between relations, if a match was found.
 
@@ -811,7 +968,7 @@ class XsdComplexType(XsdAnyType):
         to convert a request XPath element into the ORM attributes for database queries.
         """
         try:
-            pos = xpath.rindex("/")
+            pos = xpath.index("/")
             node_name = xpath[:pos]
         except ValueError:
             node_name = xpath
@@ -825,12 +982,11 @@ class XsdComplexType(XsdAnyType):
             if pos:
                 return None  # invalid attribute
 
-            # Remove app: prefixes, or any alias of it (see explanation below)
             xml_name = node_name[1:]
-            attribute = self._find_attribute(xml_name=xml_name)
+            attribute = self._find_attribute(xml_name=parse_qname(xml_name, ns_aliases))
             return [attribute] if attribute is not None else None
         else:
-            element = self._find_element(node_name)
+            element = self._find_element(xml_name=parse_qname(node_name, ns_aliases))
             if element is None:
                 return None
 
@@ -839,62 +995,34 @@ class XsdComplexType(XsdAnyType):
                     return None
                 else:
                     # Recurse into the child node to find the next part
-                    child_path = element.type.resolve_element_path(xpath[pos + 1 :])
+                    child_path = element.type.resolve_element_path(xpath[pos + 1 :], ns_aliases)
                     return [element] + child_path if child_path is not None else None
             else:
                 return [element]
 
-    def _find_element(self, xml_name) -> XsdElement | None:
+    def _find_element(self, xml_name: str) -> XsdElement | None:
         """Locate an element by name"""
         for element in self.elements:
             if element.xml_name == xml_name:
                 return element
 
-        prefix, name = split_xml_name(xml_name)
-        if prefix != "gml" and prefix != self.prefix:
-            # Ignore current app namespace. Note this should actually compare the
-            # xmlns URI's, but this will suffice for now. The ElementTree parser
-            # doesn't provide access to 'xmlns' definitions on the element (or it's
-            # parents), so a tag like this is essentially not parsable for us:
-            # <ValueReference xmlns:tns="http://...">tns:fieldname</ValueReference>
-            for element in self.elements:
-                if element.name == name:
-                    return element
-
         # When there is a base class, resolve elements there too.
-        if self.base.is_complex_type:
+        if self.base is not None and self.base.is_complex_type:
             return self.base._find_element(xml_name)
         return None
 
-    def _find_attribute(self, xml_name) -> XsdAttribute | None:
+    def _find_attribute(self, xml_name: str) -> XsdAttribute | None:
         """Locate an attribute by name"""
         for attribute in self.attributes:
             if attribute.xml_name == xml_name:
                 return attribute
 
-        prefix, name = split_xml_name(xml_name)
-        if prefix != "gml" and prefix != self.prefix:
-            # Allow any namespace to match, since the stdlib ElementTree parser
-            # can't resolve namespaces at all.
-            for attribute in self.attributes:
-                if attribute.name == name:
-                    return attribute
-
         # When there is a base class, resolve attributes there too.
-        if self.base.is_complex_type:
+        if self.base is not None and self.base.is_complex_type:
             return self.base._find_attribute(xml_name)
         return None
 
 
-def split_xml_name(xml_name: str) -> tuple[str | None, str]:
-    """Remove the namespace prefix from an element."""
-    try:
-        prefix, name = xml_name.split(":", 1)
-        return prefix, name
-    except ValueError:
-        return None, xml_name
-
-
 class ORMPath:
     """Base class to provide raw XPath results.
 
@@ -918,7 +1046,7 @@ class ORMPath:
 
     def build_lhs(self, compiler: CompiledQuery):
         """Give the ORM part when this element is used as left-hand-side of a comparison.
-        For example: "path == value".
+        For example: ``path == value``.
         """
         if self.is_many:
             compiler.add_distinct()
@@ -928,7 +1056,7 @@ class ORMPath:
 
     def build_rhs(self, compiler: CompiledQuery):
         """Give the ORM part when this element would be used as right-hand-side.
-        For example: "path == path" or "value == path".
+        For example: ``path1 == path2`` or ``value == path``.
         """
         if self.is_many:
             compiler.add_distinct()
@@ -961,10 +1089,10 @@ class XPathMatch(ORMPath):
             # the build_...() logic should return a Q() object.
             raise NotImplementedError(f"Complex XPath queries are not supported yet: {self.query}")
 
-    @cached_property
+    @property
     def orm_path(self) -> str:
         """Give the Django ORM path (field__relation__relation2) to the result."""
-        return "__".join(xsd_node.orm_path for xsd_node in self.nodes)
+        return self.nodes[-1].orm_path
 
     def __iter__(self):
         return iter(self.nodes)
@@ -986,7 +1114,9 @@ class XPathMatch(ORMPath):
         return any(node.is_many for node in self.nodes)
 
     def build_lhs(self, compiler: CompiledQuery):
-        """Delegate the LHS construction to the final XsdNode."""
+        """Give the ORM part when this element is used as left-hand-side of a comparison.
+        For example: ``path == value``.
+        """
         if self.is_many:
             compiler.add_distinct()
         if self.orm_filters:
@@ -994,7 +1124,9 @@ class XPathMatch(ORMPath):
         return self.child.build_lhs_part(compiler, self)
 
     def build_rhs(self, compiler: CompiledQuery):
-        """Delegate the RHS construction to the final XsdNode."""
+        """Give the ORM part when this element would be used as right-hand-side.
+        For example: ``path1 == path2`` or ``value == path``.
+        """
         if self.is_many:
             compiler.add_distinct()
         if self.orm_filters:
@@ -1004,4 +1136,4 @@ class XPathMatch(ORMPath):
 
 if TYPE_CHECKING:
     from .features import FeatureType
-    from .parsers.fes20 import CompiledQuery
+    from .parsers.query import CompiledQuery