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

{django_gisserver-1.4.0.dist-info → django_gisserver-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-gisserver
-Version: 1.4.0
+Version: 1.5.0
 Summary: Django speaking WFS 2.0 (exposing GeoDjango model fields)
 Home-page: https://github.com/amsterdam/django-gisserver
 Author: Diederik van der Boor
@@ -12,33 +12,35 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 3.2
 Classifier: Framework :: Django :: 4.0
 Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires: Django (>=3.2)
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: Django >=3.2
-Requires-Dist: defusedxml >=0.6.0
-Requires-Dist: lru-dict >=1.1.7
-Requires-Dist: orjson >=2.4.0
+Requires-Dist: Django>=3.2
+Requires-Dist: defusedxml>=0.6.0
+Requires-Dist: lru_dict>=1.1.7
+Requires-Dist: orjson>=3.9.15
 Provides-Extra: tests
-Requires-Dist: django-environ >=0.4.5 ; extra == 'tests'
-Requires-Dist: psycopg2-binary >=2.8.4 ; extra == 'tests'
-Requires-Dist: lxml >=4.5.0 ; extra == 'tests'
-Requires-Dist: pytest >=6.2.3 ; extra == 'tests'
-Requires-Dist: pytest-django >=4.1.0 ; extra == 'tests'
-Requires-Dist: pytest-cov >=2.11.1 ; extra == 'tests'
+Requires-Dist: django-environ>=0.4.5; extra == "tests"
+Requires-Dist: psycopg2-binary>=2.8.4; extra == "tests"
+Requires-Dist: lxml>=4.9.1; extra == "tests"
+Requires-Dist: pytest>=6.2.3; extra == "tests"
+Requires-Dist: pytest-django>=4.1.0; extra == "tests"
+Requires-Dist: pytest-cov>=2.11.1; extra == "tests"
 
 [![Documentation](https://readthedocs.org/projects/django-gisserver/badge/?version=latest)](https://django-gisserver.readthedocs.io/en/latest/?badge=latest)
 [![Actions](https://github.com/Amsterdam/django-gisserver/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/Amsterdam/django-gisserver/actions/workflows/tests.yaml)

django_gisserver-1.5.0.dist-info/RECORD

@@ -0,0 +1,54 @@
+gisserver/__init__.py,sha256=XtaIlx7Gik8RqIFDc1G0JAUfcmeNyTWjev1E1Oym_ms,40
+gisserver/conf.py,sha256=3LSfeDRTdJCLuopAOD14Y5m2iPhovreIaNI9zbaukpo,2343
+gisserver/db.py,sha256=-d6VQRkRWMSWKkA_6cVWhLzSI1cKmRoVktqA6hVwvuM,4928
+gisserver/exceptions.py,sha256=wRsiKWhZtA8NmfMNncRtMeFgWDMdOWRp9Ey96iFAwMI,5194
+gisserver/features.py,sha256=b3hEDs90xwEsANcRgipekZZrp4ucxRWwGeUutk2gRTw,31821
+gisserver/geometries.py,sha256=HLZ3d8E5M2sfs2Kzz_GE3pZdynn-rYXPpuU9GVh0vsg,12398
+gisserver/types.py,sha256=bsl3PezhGcHpUAtuV4AhdBmFLmtZZpDCT_HqpdVyLtM,36936
+gisserver/views.py,sha256=xMHKezn4F1xZ2r78l9IzUlL5M3qZ78fjRJJtSzA8-Ww,12809
+gisserver/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/operations/base.py,sha256=Ls5i6ulMJqyhqu6o969rJ-mezW-T6OW5mr8oZ3BTBH8,17222
+gisserver/operations/wfs20.py,sha256=bQeMJ4T6AisSBMABYa3li1u53w0zUxs02qBwjS4QbOw,18742
+gisserver/output/__init__.py,sha256=C6hXIVIxBd2o_1Y7VhIU9vCg7pswI2tXsd74wgMdU4o,2134
+gisserver/output/base.py,sha256=GygubFyhPO33fQw3jIuOerEH8yjbk0DJ6NhQdFkT7-g,8645
+gisserver/output/csv.py,sha256=Mm7zYzUs9ffw9fqcKY9NT7qbMX-MzSFnqBg5I1wdRU0,6459
+gisserver/output/geojson.py,sha256=bhRtNdMi1tMcSFBxDTNL8oysAMVhoolctKjZhxIncN8,11297
+gisserver/output/gml32.py,sha256=KbhcBBVp4sEhvKs5e6fP4_GKKL6Kr2yyYaDLWePBQxs,31293
+gisserver/output/results.py,sha256=VD-fJgWrMTwGaEGG_BSVhDv_m60dldBY6yAcTpRICT4,13949
+gisserver/output/utils.py,sha256=FIlkHymA43RLZAfB6-trM3_IQKbIVb_4OUp5fxRbVGY,7379
+gisserver/output/xmlschema.py,sha256=TdTMyP2_r98wkeffWAwrfm3l9XAmivu1KcYWNpgQKR4,4578
+gisserver/parsers/__init__.py,sha256=g72D8EtR-QkhcemzY5-Qty-nhHPKza83Sz3KZm8bfq0,290
+gisserver/parsers/base.py,sha256=9DE73wMphp7At3mGW0xwGU_TWPm55x8JEh4odpdRhlo,4833
+gisserver/parsers/tags.py,sha256=NyJhbt-U2zTewfhghH4LRslTaDK2UOq9Vgk83pWfJh0,3553
+gisserver/parsers/values.py,sha256=ypNPl4HduiVzexsL59ukZntlwXk5gHuSvQO6yhLeXD4,1016
+gisserver/parsers/fes20/__init__.py,sha256=72RuFxAQp9hW0pgFUDyfQ0WsStNNk6J_y3NH-zYaPOA,1140
+gisserver/parsers/fes20/expressions.py,sha256=A1-8JsGahXJPWLuTSVNAf0oSuyLfDMnFKM7viIt35Y8,9573
+gisserver/parsers/fes20/filters.py,sha256=HdWguZvAT2L4Xm-bNa4XPh7MEymqTB6fo8r47Z-Bjuw,3511
+gisserver/parsers/fes20/functions.py,sha256=mutPlbjOlg6R-9nNe8goaNdsAlZPkuckYlhMsQyp6NE,8723
+gisserver/parsers/fes20/identifiers.py,sha256=vcPrMYcsemSlB9ziSUdVulhoI5PGFAh8vqeADBCWd60,2864
+gisserver/parsers/fes20/operators.py,sha256=oQezU553Mts1DoExlH7_U29XXXdk6V84ihlBOozRzLg,23360
+gisserver/parsers/fes20/query.py,sha256=_OxElAgeo34-00pNY5Apc6TSUKokSG9VWSMmIplN7AA,10638
+gisserver/parsers/fes20/sorting.py,sha256=Uj8gsbBXumihWkrcj_pRPscwZAScUJSngAyjKri-Z8Y,2184
+gisserver/parsers/gml/__init__.py,sha256=lNK0SXWkmTKdeJD9xdK6B-N-Y7wwGL4NRBI3dzoJDNI,1463
+gisserver/parsers/gml/base.py,sha256=xWC5FrJyMjq7h5zmKwEvtRF0-CGVbCtvnO8Isvnf4mE,1065
+gisserver/parsers/gml/geometries.py,sha256=cgV3WogA7LyC_H_NF7dGoGLvLdQRACG6AlThRkX_jhU,3171
+gisserver/queries/__init__.py,sha256=yntEYRfaZ1Yjnr8lMvJt9Erh31WktikIf1af4TTuX74,1000
+gisserver/queries/adhoc.py,sha256=Hhcxwt5C2OHqtLc-3QUqx8MZEnhoqkKWjBp56e6aljc,7428
+gisserver/queries/base.py,sha256=EVJiwcLBjxGXJ8k012gGEiZ1q_gQZokSwdMl4H1SPus,7857
+gisserver/queries/projection.py,sha256=KEz9UcZGVkYq7XTm_5nx8w5TnbSqht7rOGEuTGeJwm8,9922
+gisserver/queries/stored.py,sha256=G258R9HVX3OooM5mhQF_N_JrFHLjM2y5iusrzPcN9TU,7125
+gisserver/static/gisserver/index.css,sha256=fiQuCMuiWUhhrNQD6bbUJaX5vH5OpG9qgPdELPB8cpI,163
+gisserver/templates/gisserver/index.html,sha256=yliku8jDqAOcenkbe1YnvJBnuS13MvzzsoDV8sQZ3GM,866
+gisserver/templates/gisserver/service_description.html,sha256=3EHLnQx27_nTDZFD2RH6E10EWnTN90s1DGuEj9PeBrg,993
+gisserver/templates/gisserver/wfs/feature_field.html,sha256=H5LsTAxGVGQqEpOZdEUTszQmFAZSpB9ggRJUsTdjYnw,538
+gisserver/templates/gisserver/wfs/feature_type.html,sha256=pIfa1cMsTlNIrzNiEOaq9LjzzF7_vZ9C7eN6KDBLOHE,788
+gisserver/templates/gisserver/wfs/2.0.0/describe_stored_queries.xml,sha256=4Hxw1kCnxfWXTVPbHf8IW9_qiSeIEtnxHK6z6TS3-zA,1041
+gisserver/templates/gisserver/wfs/2.0.0/get_capabilities.xml,sha256=Ej6ZXf-nGiPjiKdhNK5vAsX2iiiS12knjD0VaSzSltM,8717
+gisserver/templates/gisserver/wfs/2.0.0/list_stored_queries.xml,sha256=CIBVQrKXmGMQ6BKbX4_0ru4lXtWnW5EIgHUbIi1V0Vc,636
+gisserver/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/templatetags/gisserver_tags.py,sha256=RFGqEj-EQi9FrJiFJ7HHAQqlU4fDKVKTtZrPNwURXgA,204
+django_gisserver-1.5.0.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+django_gisserver-1.5.0.dist-info/METADATA,sha256=IWlSvP8d_4wsCVq4NWAE0T7Q8QZGqFVMvWUyLss85aY,5859
+django_gisserver-1.5.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+django_gisserver-1.5.0.dist-info/top_level.txt,sha256=8zFCEMmkpixE4TPiOAlxSq3PD2EXvAeFKwG4yZoIIOQ,10
+django_gisserver-1.5.0.dist-info/RECORD,,

{django_gisserver-1.4.0.dist-info → django_gisserver-1.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gisserver/__init__.py

@@ -1 +1 @@
-__version__ = "1.4.0"  # follows PEP440
+__version__ = "1.5.0"  # follows PEP440

gisserver/db.py

@@ -3,14 +3,13 @@
 from __future__ import annotations
 
 from functools import lru_cache, reduce
-from typing import cast
 
-from django.contrib.gis.db.models import GeometryField, functions
+from django.contrib.gis.db.models import functions
 from django.db import connection, connections, models
 
 from gisserver import conf
 from gisserver.geometries import CRS
-from gisserver.types import XPathMatch, XsdElement
+from gisserver.types import GmlElement
 
 
 class AsEWKT(functions.GeoFunc):
@@ -54,9 +53,9 @@ class ST_Union(functions.Union):
     arity = None
 
     def as_postgresql(self, compiler, connection, **extra_context):
-        # PostgreSQL can handle ST_Union(ARRAY(field names)), other databases don't.
+        # PostgreSQL can handle ST_Union(ARRAY[field names]), other databases don't.
         if len(self.source_expressions) > 2:
-            extra_context["template"] = "%(function)s(ARRAY(%(expressions)s))"
+            extra_context["template"] = "%(function)s(ARRAY[%(expressions)s])"
         return self.as_sql(compiler, connection, **extra_context)
 
 
@@ -65,7 +64,7 @@ def get_geometries_union(
 ) -> str | functions.Union:
     """Generate a union of multiple geometry fields."""
     if not expressions:
-        raise ValueError("Missing geometery fields for get_geometries_union()")
+        raise ValueError("Missing geometry fields for get_geometries_union()")
 
     if len(expressions) == 1:
         return next(iter(expressions))  # fastest in set data type
@@ -73,7 +72,7 @@ def get_geometries_union(
         return functions.Union(*expressions)
     elif connections[using].vendor == "postgresql":
         # postgres can handle multiple field names
-        return ST_Union(expressions)
+        return ST_Union(*expressions)
     else:
         # other databases do Union(Union(1, 2), 3)
         return reduce(functions.Union, expressions)
@@ -122,25 +121,20 @@ def escape_xml_name(name: str, template="{name}") -> str:
 
 
 def get_db_geometry_selects(
-    gml_elements: list[XsdElement], output_crs: CRS
+    gml_elements: list[GmlElement], output_crs: CRS
 ) -> dict[str, str | functions.Transform]:
     """Utility to generate select clauses for the geometry fields of a type.
     Key is the xsd element name, value is the database select expression.
     """
     return {
-        xsd_element.name: _get_db_geometry_target(xsd_element, output_crs)
-        for xsd_element in gml_elements
-        if xsd_element.source is not None
+        gml_element.name: get_db_geometry_target(gml_element, output_crs)
+        for gml_element in gml_elements
+        if gml_element.source is not None
     }
 
 
-def _get_db_geometry_target(xsd_element: XsdElement, output_crs: CRS) -> str | functions.Transform:
+def get_db_geometry_target(gml_element: GmlElement, output_crs: CRS) -> str | functions.Transform:
     """Wrap the selection of a geometry field in a CRS Transform if needed."""
-    field = cast(GeometryField, xsd_element.source)
-    return conditional_transform(xsd_element.orm_path, field.srid, output_srid=output_crs.srid)
-
-
-def get_db_geometry_target(xpath_match: XPathMatch, output_crs: CRS):
-    """Based on a resolved element, build the proper geometry field select clause."""
-    field = cast(GeometryField, xpath_match.child.source)
-    return conditional_transform(xpath_match.orm_path, field.srid, output_srid=output_crs.srid)
+    return conditional_transform(
+        gml_element.orm_path, gml_element.source.srid, output_srid=output_crs.srid
+    )

gisserver/exceptions.py

@@ -9,13 +9,14 @@ https://docs.opengeospatial.org/is/09-025r2/09-025r2.html#411
 """
 
 from django.conf import settings
+from django.http import HttpResponse
 from django.utils.html import format_html
 
 
 class ExternalValueError(ValueError):
     """Raise a ValueError for external input.
     This helps to distinguish between internal bugs
-    (e.g. unpacking values) and misformed external input.
+    (e.g. unpacking values) and malformed external input.
     """
 
 
@@ -32,18 +33,29 @@ class OWSException(Exception):
     version = "2.0.0"
     code = None
     text_template = None
+    debug_hint = True
 
-    def __init__(self, locator, text=None, code=None, status_code=None):
+    def __init__(self, text=None, code=None, locator=None, status_code=None):
         text = text or self.text_template.format(code=self.code, locator=locator)
+        if (code and len(text) < len(code)) or (locator and len(text) < len(locator)):
+            raise ValueError("text/locator arguments are switched")
+
         super().__init__(text)
         self.locator = locator
         self.text = text
-        self.code = code or self.code
+        self.code = code or self.code or self.__class__.__name__
         self.status_code = status_code or self.status_code
 
+    def as_response(self):
+        return HttpResponse(
+            b'<?xml version="1.0" encoding="UTF-8"?>\n%b' % self.as_xml().encode("utf-8"),
+            content_type="text/xml; charset=utf-8",
+            status=self.status_code,
+            reason=self.reason,
+        )
+
     def as_xml(self):
         return format_html(
-            '<?xml version="1.0" encoding="UTF-8"?>\n'
             "<ows:ExceptionReport"
             ' xmlns:ows="http://www.opengis.net/ows/1.1"'
             ' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"'
@@ -51,16 +63,18 @@ class OWSException(Exception):
             ' http://schemas.opengis.net/ows/1.1.0/owsExceptionReport.xsd"'
             ' xml:lang="en-US"'
             ' version="2.0.0">\n'
-            '  <ows:Exception exceptionCode="{code}" locator="{locator}">\n'
-            "    <ows:ExceptionText>{text}{debug}</ows:ExceptionText>\n"
+            '  <ows:Exception exceptionCode="{code}"{locator_attr}>\n\n'
+            "    <ows:ExceptionText>{text}{debug}</ows:ExceptionText>\n\n"
             "  </ows:Exception>\n"
-            "</ows:ExceptionReport>",
+            "</ows:ExceptionReport>\n",
             code=self.code,
-            locator=self.locator,
+            locator_attr=(
+                format_html(' locator="{locator}"', locator=self.locator) if self.locator else ""
+            ),
             text=self.text,
             debug=(
                 ".\n\n(set GISSERVER_WRAP_FILTER_DB_ERRORS=False to see the Django error page)"
-                if settings.DEBUG and self.status_code >= 500
+                if settings.DEBUG and self.status_code >= 500 and self.debug_hint
                 else ""
             ),
         )

gisserver/features.py

@@ -18,10 +18,9 @@ from __future__ import annotations
 
 import html
 import operator
-from collections import defaultdict
 from dataclasses import dataclass
 from functools import cached_property, lru_cache, reduce
-from typing import Union
+from typing import TYPE_CHECKING, Literal, Union
 
 from django.conf import settings
 from django.contrib.gis.db import models as gis_models
@@ -35,6 +34,7 @@ from gisserver.exceptions import ExternalValueError
 from gisserver.geometries import CRS, WGS84, BoundingBox
 from gisserver.types import (
     GmlBoundedByElement,
+    GmlElement,
     GmlIdAttribute,
     GmlNameElement,
     XPathMatch,
@@ -49,13 +49,10 @@ if "django.contrib.postgres" in settings.INSTALLED_APPS:
 else:
     ArrayField = None
 
-try:
-    from typing import Literal  # Python 3.8
-
-    _all_ = Literal["__all__"]
-except ImportError:
-    _all_ = str
+if TYPE_CHECKING:
+    from gisserver.queries import FeatureRelation
 
+_all_ = Literal["__all__"]
 
 __all__ = [
     "FeatureType",
@@ -125,7 +122,12 @@ def get_basic_field_type(
         return DEFAULT_XSD_TYPE
 
 
-def _get_model_fields(model, fields, parent=None):
+def _get_model_fields(
+    model: type[models.Model],
+    fields: _all_ | list[str],
+    parent: ComplexFeatureField | None = None,
+    feature_type: FeatureType | None = None,
+):
     if fields == "__all__":
         # All regular fields
         # Relationships will not be expanded since it can expose so many other fields.
@@ -136,6 +138,7 @@ def _get_model_fields(model, fields, parent=None):
                 # .bind() is called directly by providing these arguments via init:
                 model=model,
                 parent=parent,
+                feature_type=feature_type,
             )
             for f in model._meta.get_fields()
             if not f.is_relation or f.many_to_one or f.one_to_one  # ForeignKey  # OneToOneField
@@ -144,7 +147,7 @@ def _get_model_fields(model, fields, parent=None):
         # Only defined fields
         fields = [f if isinstance(f, FeatureField) else FeatureField(f) for f in fields]
         for field in fields:
-            field.bind(model, parent=parent)
+            field.bind(model, parent=parent, feature_type=feature_type)
         return fields
 
 
@@ -180,14 +183,28 @@ class FeatureField:
         model_attribute=None,
         model=None,
         parent: ComplexFeatureField | None = None,
+        feature_type: FeatureType | None = None,
         abstract=None,
         xsd_class: type[XsdElement] | None = None,
     ):
+        """
+        Initialize a single field of the feature.
+
+        :param name: Name of the model field.
+        :param model_attribute: Which model attribute to access. This can be a dotted field path.
+        :param model: Which model is accessed. Usually this is passed via :meth:`bind`.
+        :param parent: The parent field of this element. Usually this is passed via :meth:`bind`.
+        :param feature_type: The feature this field is a part of. Usually this is passed via :meth:`bind`.
+        :param abstract: The "help text" or short abstract/description for this field.
+        :param xsd_class: Override which class is used to construct the internal XsdElement.
+                          This controls the schema rendering, value retrieval and rendering of the element.
+        """
         self.name = name
         self.model_attribute = model_attribute
         self.model = None
         self.model_field = None
         self.parent = parent
+        self.feature_type = feature_type
         self.abstract = abstract
 
         # Allow to override the class attribute on 'self',
@@ -197,7 +214,7 @@ class FeatureField:
 
         self._nillable_relation = False
         if model is not None:
-            self.bind(model)
+            self.bind(model, parent=parent, feature_type=feature_type)
 
     def __repr__(self):
         return f"<{self.__class__.__name__}: {self.name}>"
@@ -209,6 +226,7 @@ class FeatureField:
         self,
         model: type[models.Model],
         parent: ComplexFeatureField | None = None,
+        feature_type: FeatureType | None = None,
     ):
         """Late-binding for the model.
 
@@ -221,11 +239,13 @@ class FeatureField:
         :param model: The model is field is linked to.
         :param parent: When this element is part of a complex feature,
                        this links to the parent field.
+        :param feature_type: The original feature type that his element was mentioned in.
         """
         if self.model is not None:
             raise RuntimeError(f"Feature field '{self.name}' cannot be reused")
         self.model = model
         self.parent = parent
+        self.feature_type = feature_type
 
         if self.model_attribute:
             # Support dot based field traversal.
@@ -285,6 +305,7 @@ class FeatureField:
             max_occurs=max_occurs,
             model_attribute=self.model_attribute,
             source=self.model_field,
+            feature_type=self.feature_type,
         )
 
 
@@ -312,9 +333,14 @@ class ComplexFeatureField(FeatureField):
     ):
         """
         :param name: Name of the model field.
-        :param fields: List of fields to expose for the target model. This can
-            be a list of :class:`FeatureField` objects, or plain field names.
+        :param fields: If the field exposes a foreign key, provide its child element names.
+            This can be a list of :func:`field` elements, or plain field names.
             Using ``__all__`` also works but is not recommended outside testing.
+        :param model_attribute: Which model attribute to access. This can be a dotted field path.
+        :param abstract: The "help text" or short abstract/description for this field.
+        :param xsd_class: Override which class is used to construct the internal XsdElement.
+                          This controls the schema rendering, value retrieval and rendering of the element.
+        :param xsd_base_type: Override which class is the base class for the element.
         """
         super().__init__(
             name,
@@ -344,6 +370,7 @@ class ComplexFeatureField(FeatureField):
                     type_name=self.name,
                     source=pk_field,
                     model_attribute=pk_field.name,
+                    feature_type=self.feature_type,
                 )
             ],
             base=self.xsd_base_type,
@@ -378,9 +405,13 @@ def field(
     so little knowledge is needed about the internal working.
 
     :param name: Name of the model field.
-    :param fields: If the field exposes a foreign key, provide it's child element names.
+    :param model_attribute: Which model attribute to access. This can be a dotted field path.
+    :param abstract: The "help text" or short abstract/description for this field.
+    :param fields: If the field exposes a foreign key, provide its child element names.
         This can be a list of :func:`field` elements, or plain field names.
         Using ``__all__`` also works but is not recommended outside testing.
+    :param xsd_class: Override which class is used to construct the internal XsdElement.
+                      This controls the schema rendering, value retrieval and rendering of the element.
     """
     if fields is not None:
         return ComplexFeatureField(
@@ -399,42 +430,6 @@ def field(
         )
 
 
-@dataclass
-class FeatureRelation:
-    """Tell which related fields are queried by the feature.
-    Each dict holds an ORM-path, with the relevant sub-elements.
-    """
-
-    #: The ORM path that is queried for this particular relation
-    orm_path: str
-    #: The fields that will be retrieved for that path
-    orm_fields: set[str]
-    #: The model that is accessed for this relation (if set)
-    related_model: type[models.Model] | None
-    #: The source elements that access this relation.
-    xsd_elements: list[XsdElement]
-
-    @cached_property
-    def _local_model_field_names(self) -> list[str]:
-        """Tell which local fields of the model will be accessed by this feature."""
-
-        meta = self.related_model._meta
-        result = []
-        for name in self.orm_fields:
-            model_field = meta.get_field(name)
-            if not model_field.many_to_many and not model_field.one_to_many:
-                result.append(name)
-
-        # When this relation is retrieved through a ManyToOneRel (reverse FK),
-        # the prefetch_related() also needs to have the original foreign key
-        # in order to link all prefetches to the proper parent instance.
-        for xsd_element in self.xsd_elements:
-            if xsd_element.source is not None and xsd_element.source.one_to_many:
-                result.append(xsd_element.source.field.name)
-
-        return result
-
-
 class FeatureType:
     """Declare a feature that is exposed on the map.
 
@@ -472,7 +467,7 @@ class FeatureType:
         :param fields: Define which fields to show in the WFS data.
             This can be a list of field names, or :class:`FeatureField` objects.
         :param display_field_name: Name of the field that's used as general string representation.
-        :param geometry_field: Name of the geometry field to expose (default = auto detect).
+        :param geometry_field_name: Name of the geometry field to expose (default = auto-detect).
         :param name: Name, also used as XML tag name.
         :param title: Used in WFS metadata.
         :param abstract: Used in WFS metadata.
@@ -530,6 +525,11 @@ class FeatureType:
         """Return all spatial reference system ID's that this feature supports."""
         return [self.crs] + self.other_crs
 
+    @cached_property
+    def geometry_elements(self) -> list[GmlElement]:
+        """Tell which fields of the XSD have a geometry field."""
+        return [ff.xsd_element for ff in self.fields if ff.xsd_element.is_geometry]
+
     @cached_property
     def geometry_fields(self) -> list[GeometryField]:
         """Tell which fields of the model have a geometry field.
@@ -541,59 +541,15 @@ class FeatureType:
             if ff.xsd_element.is_geometry
         ]
 
-    @cached_property
-    def orm_relations(self) -> list[FeatureRelation]:
-        """Tell which fields will be retrieved from related fields.
-
-        This gives an object layout based on the XSD elements,
-        that can be used for prefetching data.
-        """
-        models = {}
-        fields = defaultdict(set)
-        elements = defaultdict(list)
-
-        # Check all elements that render as "dotted" flattened relation
-        for xsd_element in self.xsd_type.flattened_elements:
-            if xsd_element.source is not None:
-                # Split "relation.field" notation into path, and take the field as child attribute.
-                obj_path, field = xsd_element.orm_relation
-                elements[obj_path].append(xsd_element)
-                fields[obj_path].add(field)
-                # field is already on relation:
-                models[obj_path] = xsd_element.source.model
-
-        # Check all elements that render as "nested" complex type:
-        for xsd_element in self.xsd_type.complex_elements:
-            # The complex element itself points to the root of the path,
-            # all sub elements become the child attributes.
-            obj_path = xsd_element.orm_path
-            elements[obj_path].append(xsd_element)
-            fields[obj_path] = {
-                f.orm_path
-                for f in xsd_element.type.elements
-                if not f.is_many or f.is_array  # exclude M2M, but include ArrayField
-            }
-            if xsd_element.source:
-                # field references a related object:
-                models[obj_path] = xsd_element.source.related_model
-
-        return [
-            FeatureRelation(
-                orm_path=obj_path,
-                orm_fields=sub_fields,
-                related_model=models.get(obj_path),
-                xsd_elements=elements[obj_path],
-            )
-            for obj_path, sub_fields in fields.items()
-        ]
-
     @cached_property
     def _local_model_field_names(self) -> list[str]:
         """Tell which local fields of the model will be accessed by this feature."""
         return [
             (ff.model_field.name if ff.model_field else ff.model_attribute)
             for ff in self.fields
-            if not ff.model_field.many_to_many and not ff.model_field.one_to_many
+            if not ff.model_field.many_to_many
+            and not ff.model_field.one_to_many
+            and not (ff.model_attribute and "." in ff.model_attribute)
         ]
 
     @cached_property
@@ -609,9 +565,9 @@ class FeatureType:
                     if isinstance(f, gis_models.GeometryField)
                 )
 
-            return [FeatureField(self._geometry_field_name, model=self.model)]
+            return [FeatureField(self._geometry_field_name, model=self.model, feature_type=self)]
         else:
-            return _get_model_fields(self.model, self._fields)
+            return _get_model_fields(self.model, self._fields, feature_type=self)
 
     @cached_property
     def display_field(self) -> models.Field | None:
@@ -652,6 +608,13 @@ class FeatureType:
             # Default: take the first geometry
             return self.geometry_fields[0]
 
+    @cached_property
+    def main_geometry_element(self) -> GmlElement:
+        """Give access to the main geometry element."""
+        # NOTE: this property should make it easier to move away from having a main geometry field
+        # at the model level, and allow a geometry field in any depth of the data model.
+        return next((e for e in self.geometry_elements if e.source is self.geometry_field), None)
+
     @cached_property
     def geometry_field_name(self) -> str:
         """Tell which field is the geometry field."""
@@ -771,6 +734,7 @@ class FeatureType:
                     type_name=self.name,
                     source=pk_field,
                     model_attribute=pk_field.name,
+                    feature_type=self,
                 )
             ],
             base=XsdTypes.gmlAbstractGMLType,

gisserver/geometries.py

@@ -123,7 +123,7 @@ class CRS:
 
     @classmethod
     def from_srid(cls, srid: int, backend=None):
-        """Instantiate this class using an numeric spatial reference ID
+        """Instantiate this class using a numeric spatial reference ID
 
         This is logically identical to calling::
 
@@ -142,7 +142,7 @@ class CRS:
 
     @classmethod
     def _from_urn(cls, urn, backend=None):  # noqa: C901
-        """Instantiate this class using an URN format."""
+        """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}")