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

gisserver/parsers/gml/geometries.py

@@ -6,15 +6,16 @@ Overview of GML 3.2 changes: https://mapserver.org/el/development/rfc/ms-rfc-105
 from dataclasses import dataclass
 from xml.etree.ElementTree import tostring
 
+from django.contrib.gis.gdal import AxisOrder
 from django.contrib.gis.geos import GEOSGeometry, Polygon
 
+from gisserver.crs import CRS
 from gisserver.exceptions import ExternalParsingError
-from gisserver.geometries import CRS
 from gisserver.parsers.ast import tag_registry
 from gisserver.parsers.query import CompiledQuery
 from gisserver.parsers.xml import NSElement, xmlns
 
-from .base import AbstractGeometry, TM_Object
+from .base import AbstractGeometry, AbstractTimePrimitive
 
 _ANY_GML_NS = "{http://www.opengis.net/gml/"
 
@@ -71,6 +72,7 @@ class GEOSGMLGeometry(AbstractGeometry):
             crs = None  # will be resolved
 
         # Wrap in an element that the filter can use.
+        CRS.tag_geometry(polygon, axis_order=AxisOrder.AUTHORITY)
         return cls(srs=crs, geos_data=polygon)
 
     @classmethod
@@ -87,11 +89,18 @@ class GEOSGMLGeometry(AbstractGeometry):
         # This avoids having to support the whole GEOS logic.
         geos_data = GEOSGeometry.from_gml(tostring(element))
         geos_data.srid = srs.srid
+
+        # Using the WFS 2 format (urn:ogc:def:crs:EPSG::4326"), coordinates should be latitude/longitude.
+        # However, when providing legacy formats like srsName="EPSG:4326",
+        # input is assumed to be in legacy longitude/latitude axis ordering too.
+        # This reflects what GeoServer does: https://docs.geoserver.org/main/en/user/services/wfs/axis_order.html
+        if not srs.force_xy:
+            CRS.tag_geometry(geos_data, axis_order=AxisOrder.AUTHORITY)
         return cls(srs=srs, geos_data=geos_data)
 
     def __repr__(self):
         # Better rendering for unit test debugging
-        return f"GMLGEOSGeometry(srs={self.srs!r}, geos_data=GEOSGeometry({self.geos_data.wkt!r}))"
+        return f"{self.__class__.__name__}(srs={self.srs!r}, geos_data=GEOSGeometry({self.geos_data.wkt!r}))"
 
     @property
     def wkt(self) -> str:
@@ -112,23 +121,47 @@ class GEOSGMLGeometry(AbstractGeometry):
         elif compiler.feature_types:  # for unit tests
             self.srs = compiler.feature_types[0].resolve_crs(self.srs, locator="bbox")
 
-        return self.geos_data
-
-
-@tag_registry.register("After")
-@tag_registry.register("Before")
-@tag_registry.register("Begins")
-@tag_registry.register("BegunBy")
-@tag_registry.register("TContains")
-@tag_registry.register("TEquals")
-@tag_registry.register("TOverlaps")
-@tag_registry.register("During")
-@tag_registry.register("Meets")
-@tag_registry.register("OverlappedBy")
-@tag_registry.register("MetBy")
-@tag_registry.register("EndedBy")
-@tag_registry.register("AnyInteracts")
-class TM_GeometricPrimitive(TM_Object):
-    """Not implemented: the whole GML temporal logic"""
+        # Make sure the data is suitable for processing by the ORM.
+        # The database needs the geometry in traditional (x/y) ordering.
+        if self.srs.is_north_east_order:
+            return self.srs.apply_to(self.geos_data, clone=True, axis_order=AxisOrder.TRADITIONAL)
+        else:
+            return self.geos_data
+
+
+@tag_registry.register("TimeInstant", hidden=True)
+@tag_registry.register("TimePeriod", hidden=True)
+class AbstractTimeGeometricPrimitive(AbstractTimePrimitive):
+    """Not implemented: the whole GML temporal logic.
+
+    Examples for GML time elements include::
+
+      <gml:TimeInstant gml:id="TI1">
+         <gml:timePosition>2005-05-19T09:28:40Z</gml:timePosition>
+      </gml:TimeInstant>
+
+    and::
+
+      <gml:TimePeriod gml:id="TP1">
+         <gml:begin>
+            <gml:TimeInstant gml:id="TI1">
+               <gml:timePosition>2005-05-17T00:00:00Z</gml:timePosition>
+            </gml:TimeInstant>
+         </gml:begin>
+         <gml:end>
+            <gml:TimeInstant gml:id="TI2">
+               <gml:timePosition>2005-05-23T00:00:00Z</gml:timePosition>
+            </gml:TimeInstant>
+         </gml:end>
+      </gml:TimePeriod>
+    """
+
+    xml_ns = xmlns.gml32
+
+
+@tag_registry.register("TimeNode", hidden=True)
+@tag_registry.register("TimeEdge", hidden=True)
+class AbstractTimeTopologyPrimitiveType(AbstractTimePrimitive):
+    """Not implemented: GML temporal logic for TimeNode/TimeEdge."""
 
     xml_ns = xmlns.gml32

gisserver/parsers/ows/kvp.py

@@ -105,7 +105,9 @@ class KVPRequest:
     def split_parameter_lists(self) -> list[KVPRequest]:
         """Split the parameter lists into individual requests.
 
-        This translates a request such as::
+        This translates a request such as:
+
+        .. code-block:: urlencoded
 
             TYPENAMES=(ns1:F1,ns2:F2)(ns1:F1,ns1:F1)
             &ALIASES=(A,B)(C,D)
@@ -113,15 +115,21 @@ class KVPRequest:
 
         into separate pairs:
 
+        .. code-block:: urlencoded
+
             TYPENAMES=ns1:F1,ns2:F2&ALIASES=A,B&FILTER=<Filter>…for A,B…</Filter>
             TYPENAMES=ns1:F1,ns1:F1&ALIASES=C,D&FILTER=<Filter>…for C,D…</Filter>
 
         It's both possible have some query parameters split and some shared.
         For example to have two different bounding boxes:
 
+        .. code-block:: urlencoded
+
              TYPENAMES=(INWATER_1M)(BuiltUpA_1M)&BBOX=(40.9821,...)(40.5874,...)
 
-        or have a single bounding box for both queries::
+        or have a single bounding box for both queries:
+
+        .. code-block:: urlencoded
 
              TYPENAMES=(INWATER_1M)(BuiltUpA_1M)&BBOX=40.9821,23.4948,41.0257,23.5525
         """

gisserver/parsers/ows/requests.py

@@ -13,7 +13,7 @@ from gisserver.exceptions import (
     OperationNotSupported,
     OperationParsingFailed,
 )
-from gisserver.parsers.ast import BaseNode, tag_registry
+from gisserver.parsers.ast import AstNode, tag_registry
 from gisserver.parsers.xml import NSElement, parse_xml_from_string, split_ns, xmlns
 
 from .kvp import KVPRequest
@@ -28,7 +28,7 @@ __all__ = (
 
 
 @dataclass
-class BaseOwsRequest(BaseNode):
+class BaseOwsRequest(AstNode):
     """Base request data for all request types of the OWS standards.
     This mirrors the ``<wfs:BaseRequestType>`` element from the WFS spec.
     """
@@ -80,7 +80,7 @@ class BaseOwsRequest(BaseNode):
         return {
             "SERVICE": self.service,
             "VERSION": str(self.version),
-            "REQUEST": split_ns(self.xml_tags[0])[1],
+            "REQUEST": split_ns(self.xml_name)[1],
         }
 
 
@@ -118,7 +118,9 @@ def resolve_kvp_parser_class(kvp: KVPRequest) -> type[BaseOwsRequest]:
     try:
         request_cls = request_classes[request.upper()]
     except KeyError:
-        allowed = ", ".join(node.xml_tags[0] for node in request_classes.values())
+        allowed = ", ".join(
+            xml_tag for node in request_classes.values() for xml_tag in node.get_tag_names()
+        )
         raise OperationNotSupported(
             f"'{request}' is not implemented, supported are: {allowed}.",
             locator="request",

gisserver/parsers/query.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 import operator
 from datetime import date, datetime
+from decimal import Decimal as D
 from functools import reduce
 from typing import Union
 
@@ -16,14 +17,15 @@ from django.db.models.expressions import Combinable, Func
 from gisserver.features import FeatureType
 
 logger = logging.getLogger(__name__)
-RhsTypes = Union[Combinable, Func, Q, GEOSGeometry, bool, int, str, date, datetime, tuple]
+ScalarTypes = (bool, int, str, D, date, datetime)  # Not Union for Python 3.9
+RhsTypes = Union[Combinable, Func, Q, GEOSGeometry, bool, int, D, str, date, datetime, tuple]
 
 
 class CompiledQuery:
     """Intermediate data for translating FES queries to Django.
 
     This class effectively contains all data from the ``<fes:Filter>`` object,
-    but using a format that can be translated to a django QuerySet.
+    but using a format that can be translated to a Django QuerySet.
 
     As the Abstract Syntax Tree of a FES-filter creates the ORM query,
     it fills this object with all intermediate bits. This allows building
@@ -64,6 +66,7 @@ class CompiledQuery:
         return name
 
     def add_distinct(self):
+        """Enforce "SELECT DISTINCT" on the query, used when joining 1-N or N-M relationships."""
         self.distinct = True
 
     def add_lookups(self, q_object: Q, type_name: str | None = None):
@@ -87,6 +90,7 @@ class CompiledQuery:
         """
         if not isinstance(q_object, Q):
             raise TypeError()
+        # Note the ORM also provides a FilteredRelation() option, that is not explored yet here.
         self.extra_lookups.append(q_object)
 
     def add_ordering(self, ordering: list[str]):

gisserver/parsers/values.py

@@ -1,9 +1,11 @@
+"""Parsing of scalar values in the request."""
+
 import logging
 import re
-from datetime import datetime
+from datetime import date, datetime, time
 from decimal import Decimal as D
 
-from django.utils.dateparse import parse_datetime
+from django.utils.dateparse import parse_date, parse_datetime, parse_duration, parse_time
 
 from gisserver.exceptions import ExternalParsingError
 
@@ -12,7 +14,15 @@ RE_FLOAT = re.compile(r"\A[0-9]+(\.[0-9]+)\Z")
 
 
 def auto_cast(value: str):
-    """Automatically cast a value to a scalar."""
+    """Automatically cast a value to a scalar.
+
+    This recognizes integers, floats and ISO datetimes.
+    Booleans are not handled, as that leads to unpredictable behavior
+    (as seen in Yaml for example).
+    """
+    if not isinstance(value, str):
+        return value
+
     if value.isdigit():
         return int(value)
     elif RE_FLOAT.match(value):
@@ -26,14 +36,61 @@ def auto_cast(value: str):
     return value
 
 
+def parse_iso_date(raw_value: str) -> date:
+    """Translate ISO date into a Python date value."""
+    try:
+        value = parse_date(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
+    if value is None:
+        raise ExternalParsingError("Date must be in YYYY-MM-DD format.")
+    return value
+
+
 def parse_iso_datetime(raw_value: str) -> datetime:
-    value = parse_datetime(raw_value)
+    """Translate ISO datetimes into a Python datetime value."""
+    try:
+        value = parse_datetime(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
     if value is None:
         raise ExternalParsingError("Date must be in YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format.")
     return value
 
 
+def parse_iso_time(raw_value: str) -> time:
+    """Translate ISO times into a Python time value."""
+    try:
+        value = parse_time(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
+    if value is None:
+        raise ExternalParsingError("Time must be in HH:MM[:ss[.uuuuuu]][TZ] format.")
+    return value
+
+
+def parse_iso_duration(raw_value: str) -> time:
+    """Translate ISO times into a Python time value."""
+    # The parse_duration() supports multiple formats, including ISO8601.
+    # Limit it to only one format.
+    if not raw_value.startswith(("P", "-P")):
+        raise ExternalParsingError("Duration must be in ISO8601 format (e.g. PT1H).")
+
+    try:
+        value = parse_duration(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
+    if value is None:
+        raise ExternalParsingError("Duration must be in ISO8601 format (e.g. PT1H).")
+    return value
+
+
 def parse_bool(raw_value: str):
+    """Translate XML notations of true/1 and false/0 into a boolean."""
     if raw_value in ("true", "1"):
         return True
     elif raw_value in ("false", "0"):

gisserver/parsers/wfs20/__init__.py

@@ -1,5 +1,7 @@
 """WFS 2.0 element parsing.
 
+These classes parse the XML request body.
+
 The full spec can be found at: https://www.ogc.org/publications/standard/wfs/.
 Secondly, using https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/wfs_xsd.html can be very
 helpful to see which options each object type should support.

gisserver/parsers/wfs20/adhoc.py

@@ -14,12 +14,12 @@ from functools import cached_property
 
 from django.db.models import Q
 
+from gisserver.crs import CRS
 from gisserver.exceptions import (
     InvalidParameterValue,
     MissingParameterValue,
     OperationNotSupported,
 )
-from gisserver.geometries import CRS
 from gisserver.parsers import fes20
 from gisserver.parsers.ast import tag_registry
 from gisserver.parsers.ows import KVPRequest
@@ -48,7 +48,9 @@ class AdhocQuery(QueryExpression):
             <fes:SortBy>...</fes:SortBy>
         </wfs:Query>
 
-    And supports the KVP syntax::
+    And supports the KVP syntax:
+
+    .. code-block:: urlencoded
 
         ?SERVICE=WFS&...&TYPENAMES=ns:myType&FILTER=...&SORTBY=...&SRSNAME=...&PROPERTYNAME=...
         ?SERVICE=WFS&...&TYPENAMES=ns:myType&BBOX=...&SORTBY=...&SRSNAME=...&PROPERTYNAME=...
@@ -59,7 +61,7 @@ class AdhocQuery(QueryExpression):
 
     The WFS Spec has 3 class levels for this:
 
-    - AdhocQueryExpression (types, projection, selection, sorting)
+     - AdhocQueryExpression (types, projection, selection, sorting)
      - Query (adds srsName, featureVersion)
      - StoredQuery (adds storedQueryID)
 
@@ -71,25 +73,31 @@ class AdhocQuery(QueryExpression):
         https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/query_xsd.html#AbstractAdhocQueryExpressionType
     """
 
-    # Tag attributes (fes:AbstractAdhocQueryExpression)
+    # Tag attributes (implements ``fes:AbstractAdhocQueryExpression``)
     # WFS allows multiple names to construct JOIN queries.
     # See https://docs.ogc.org/is/09-025r2/09-025r2.html#107
     # and https://docs.ogc.org/is/09-025r2/09-025r2.html#190
-    typeNames: list[str]  # typeNames in WFS/FES spec, multiple values means a JOIN is made.
-    aliases: list[str] | None = None  # aliases for typeNames for joining the same table twice.
-    handle: str = ""  # only for XML POST requests, is returned in ows:Exception
-    # Query tag attributes
+
+    #: The 'typeNames' value if the request provided them. use :meth:`get_type_names` instead.
+    typeNames: list[str]
+    #: Aliases for typeNames are used for joining the same table twice. (JOIN statements are not supported yet).
+    aliases: list[str] | None = None
+    #: For XML POST requests, this handle value is returned in the ``<ows:Exception>``.
+    handle: str = ""
+
+    # part of the <wfs:Query> tag attributes:
+    #: The Coordinate Reference System to render the tag in
     srsName: CRS | None = None
 
-    # Projection clause (fes:AbstractProjectionClause)
+    #: Projection clause (implements ``fes:AbstractProjectionClause``)
     property_names: list[PropertyName] | None = None
 
-    # Selection clause (fes:AbstractSelectionClause):
-    # - for XML POST this is encoded in a <fes:Query>
-    # - for HTTP GET, this is encoded as FILTER, FILTER_LANGUAGE, RESOURCEID, BBOX.
+    #: Selection clause (implements ``fes:AbstractSelectionClause``).
+    #: - for XML POST this is encoded in a <fes:Filter> tag.
+    #: - for HTTP GET, this is encoded as FILTER, FILTER_LANGUAGE, RESOURCEID, BBOX.
     filter: fes20.Filter | None = None
 
-    # Sorting Clause (fes:AbstractSortingClause)
+    #: Sorting Clause (implements ``fes:AbstractSortingClause``)
     sortBy: fes20.SortBy | None = None
 
     def __post_init__(self):
@@ -188,7 +196,9 @@ class AdhocQuery(QueryExpression):
             return "filter"
 
     def get_type_names(self) -> list[str]:
-        """Tell which type names this query uses."""
+        """Tell which type names this query uses.
+        Multiple values means a JOIN is made (not supported yet).
+        """
         if not self.typeNames and self.filter is not None:
             # Also make the behavior consistent, always supply the type name.
             return self.filter.get_resource_id_types() or []
@@ -196,7 +206,7 @@ class AdhocQuery(QueryExpression):
             return self.typeNames
 
     def get_projection(self) -> FeatureProjection:
-        """Tell how the <wfs:Query> element should be displayed."""
+        """Tell how the ``<wfs:Query>`` element should be displayed."""
         return FeatureProjection(
             self.feature_types,
             self.property_names,
@@ -205,7 +215,7 @@ class AdhocQuery(QueryExpression):
         )
 
     def bind(self, *args, **kwargs):
-        """Make sure the 'locator' points to the actual object that defined the type."""
+        """Override to make sure the 'locator' points to the actual object that defined the type."""
         try:
             super().bind(*args, **kwargs)
         except InvalidParameterValue as e:
@@ -219,7 +229,7 @@ class AdhocQuery(QueryExpression):
 
     def build_query(self, compiler: CompiledQuery) -> Q | None:
         """Apply our collected filter data to the compiler."""
-        # Add the
+        # Add the sorting
         if self.sortBy is not None:
             self.sortBy.build_ordering(compiler)
 
@@ -230,7 +240,7 @@ class AdhocQuery(QueryExpression):
         else:
             return None
 
-    def as_kvp(self):
+    def as_kvp(self) -> dict:
         """Translate the POST request into KVP GET parameters. This is needed for pagination."""
         params = super().as_kvp()
         params["TYPENAMES"] = ",".join(self.typeNames)

gisserver/parsers/wfs20/base.py

@@ -23,12 +23,12 @@ from gisserver.exceptions import (
 )
 from gisserver.features import FeatureType
 from gisserver.parsers import fes20, wfs20
-from gisserver.parsers.ast import BaseNode
+from gisserver.parsers.ast import AstNode
 from gisserver.parsers.query import CompiledQuery
 from gisserver.projection import FeatureProjection
 
 
-class QueryExpression(BaseNode):
+class QueryExpression(AstNode):
     """WFS base class for all queries.
     This object type is defined in the WFS spec (as ``<fes:AbstractQueryExpression>``).
 
@@ -47,16 +47,20 @@ class QueryExpression(BaseNode):
     * :meth:`get_queryset` defines the full results.
     """
 
+    #: Configuration for the 'locator' argument in exceptions
     query_locator: ClassVar[str] = None
 
     # QueryExpression
+    #: The 'handle' that will be returned in exceptions.
     handle: str = ""
 
-    # Projection parameters (overwritten by subclasses)
-    # In the WFS spec, this is only part of the operation/presentation.
-    # For Django, we'd like to make this part of the query too.
+    #: Projection parameters (overwritten by subclasses)
+    #: In the WFS spec, this is only part of the operation/presentation.
+    #: For Django, we'd like to make this part of the query too.
     property_names: list[wfs20.PropertyName] | None = None  # PropertyName
-    value_reference: fes20.ValueReference | None = None  # GetPropertyValue call
+
+    #: The valueReference for the GetPropertyValue call, provided here for extra ORM filtering.
+    value_reference: fes20.ValueReference | None = None
 
     def bind(
         self,
@@ -120,6 +124,7 @@ class QueryExpression(BaseNode):
 
     def get_type_names(self) -> list[str]:
         """Tell which type names this query applies to.
+        Multiple values means a JOIN is made (not supported yet).
 
         This method needs to be defined in subclasses.
         """
@@ -135,7 +140,7 @@ class QueryExpression(BaseNode):
         """Define the compiled query that filters the queryset."""
         raise NotImplementedError()
 
-    def as_kvp(self):
+    def as_kvp(self) -> dict:
         """Translate the POST request into KVP GET parameters. This is needed for pagination."""
         params = {}
         if self.property_names:

gisserver/parsers/wfs20/projection.py

@@ -10,14 +10,14 @@ from gisserver.exceptions import (
     OperationParsingFailed,
     OperationProcessingFailed,
 )
-from gisserver.parsers.ast import BaseNode, tag_registry
+from gisserver.parsers.ast import AstNode, tag_registry
 from gisserver.parsers.query import CompiledQuery
 from gisserver.parsers.xml import NSElement, xmlns
 from gisserver.types import XPathMatch
 
 
 class ResolveValue(Enum):
-    """The wfs:ResolveValueType enum, used by :class:`StandardResolveParameters`."""
+    """The ``wfs:ResolveValueType`` enum, used by :class:`StandardResolveParameters`."""
 
     local = "local"
     remote = "remote"
@@ -31,7 +31,7 @@ class ResolveValue(Enum):
 
 @dataclass
 @tag_registry.register("PropertyName", xmlns.wfs)
-class PropertyName(BaseNode):
+class PropertyName(AstNode):
     """The ``<wfs:PropertyName>`` element in the projection clause.
 
     This parses and handles the syntax::

gisserver/parsers/wfs20/requests.py

@@ -45,6 +45,7 @@ WFS_STORED_QUERY = xmlns.wfs20.qname("StoredQuery")
 
 @dataclass
 @tag_registry.register("GetCapabilities", xmlns.wfs20)
+@tag_registry.register("GetCapabilities", xmlns.wfs1, hidden=True)  # to give negotiation error.
 class GetCapabilities(BaseOwsRequest):
     """Request parsing for GetCapabilities.
 

gisserver/parsers/wfs20/stored.py

@@ -60,7 +60,7 @@ class StoredQuery(QueryExpression):
     Note that the base class logic (such as ``<wfs:PropertyName>`` elements) are still applicable.
 
     This element resolves the stored query using the
-    :class:`~gisserver.projection.storage.StoredQueryRegistry`,
+    :class:`~gisserver.extensions.queries.StoredQueryRegistry`,
     and passes the execution to this custom function.
     """
 
@@ -165,7 +165,8 @@ class StoredQuery(QueryExpression):
         """Forward queryset creation to the implementation class."""
         return self.implementation.build_query(compiler)
 
-    def as_kvp(self):
+    def as_kvp(self) -> dict:
+        """Translate the POST request into KVP GET parameters. This is needed for pagination."""
         # As this is such edge case, only support the minimal for CITE tests.
         params = super().as_kvp()
         params["STOREDQUERY_ID"] = self.id

gisserver/parsers/xml.py

@@ -50,8 +50,10 @@ class xmlns(Enum):
     ows20 = "http://www.opengis.net/ows/2.0"
     wms = "http://www.opengis.net/wms"  # Web Map Service (WMS)
     wcs = "http://www.opengis.net/wcs"  # Web Coverage Service (WCS)
+    wcs20 = "http://www.opengis.net/wcs/2.0"
     wps = "http://www.opengis.net/wps/1.0.0"  # Web Processing Service (WPS)
     wmts = "http://www.opengis.net/wmts/1.0"  # Web Map Tile Service (WMTS)
+    wfs1 = "http://www.opengis.net/wfs"
     wfs20 = "http://www.opengis.net/wfs/2.0"  # Web Feature Service (WFS)
     fes20 = "http://www.opengis.net/fes/2.0"  # Filter Encoding Standard (FES)
     gml21 = "http://www.opengis.net/gml"
@@ -108,6 +110,16 @@ class NSElement(Element):
         """Resolve an aliased QName value to its fully qualified name."""
         return parse_qname(qname, self.ns_aliases)
 
+    @property
+    def qname(self) -> str:
+        """Provde the tag name in its original short format"""
+        ns, localname = split_ns(self.tag)
+        if ns:
+            for prefix, full_ns in self.ns_aliases.items():
+                if full_ns == ns:
+                    return f"{prefix}:{localname}" if prefix else localname
+        return localname
+
     def get_str_attribute(self, name: str) -> str:
         """Resolve an attribute, raise an error when it's missing."""
         try:

gisserver/projection.py

@@ -29,8 +29,8 @@ if typing.TYPE_CHECKING:
     from django.contrib.gis.geos import GEOSGeometry
     from django.db import models
 
+    from gisserver.crs import CRS
     from gisserver.features import FeatureType
-    from gisserver.geometries import CRS
     from gisserver.parsers import fes20, wfs20
 
 __all__ = (
@@ -47,14 +47,25 @@ class FeatureProjection:
 
     Instead of walking over the full XSD object tree,
     this object wraps that and makes sure only the actual requested fields are used.
-    When a PROPERTYNAME is used in the request, this will limit
-    which fields to retrieve, which to prefetch, and which to render.
+    When a ``PROPERTYNAME`` (or ``<wfs:PropertyName>``) is used in the request,
+    this will limit which fields to retrieve, which to prefetch, and which to render.
     """
 
+    #: Referencing the Feature that is rendered.
     feature_type: FeatureType
+
+    #: The list of root element to render for this feature.
     xsd_root_elements: list[XsdElement]
+
+    #: The subset of child nodes to render for a given element.
     xsd_child_nodes: dict[XsdElement | None, list[XsdElement]]
 
+    #: The output Coordinate Reference System
+    output_crs: CRS
+
+    #: Whether the output should be rendered without wrapper tags (for GetFeatureById).
+    output_standalone: bool
+
     def __init__(
         self,
         feature_types: list[FeatureType],
@@ -69,7 +80,8 @@ class FeatureProjection:
         :param property_names: Limited list of fields to render only.
         :param value_reference: Single element to display fo GetPropertyValue
         :param output_crs: Which coordinate reference system to use for geometry data.
-        :param output_standalone: Whether the ``<wfs:
+        :param output_standalone: Used for the ``GetFeatureById`` stored query.
+            This removes the ``wfs:FeatureCollection><wfs:member>`` wrapper elements from the output.
         """
         self.feature_types = feature_types
         self.feature_type = feature_types[0]  # JOIN still not supported.
@@ -302,9 +314,7 @@ class FeatureProjection:
 
 @dataclass
 class FeatureRelation:
-    """Tell which related fields are queried by the feature.
-    Each dict holds an ORM-path, with the relevant sub-elements.
-    """
+    """Tell which related fields are queried by the feature."""
 
     #: The ORM path that is queried for this particular relation
     orm_path: str