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

{django_gisserver-1.4.1.dist-info → django_gisserver-2.0.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: django-gisserver
-Version: 1.4.1
+Version: 2.0
 Summary: Django speaking WFS 2.0 (exposing GeoDjango model fields)
 Home-page: https://github.com/amsterdam/django-gisserver
 Author: Diederik van der Boor
 Author-email: opensource@edoburu.nl
 License: Mozilla Public License 2.0
-Classifier: Development Status :: 4 - Beta
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
@@ -16,6 +17,7 @@ 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: Programming Language :: Python :: 3.13
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 3.2
 Classifier: Framework :: Django :: 4.0
@@ -27,20 +29,20 @@ 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.8
+Requires-Python: >=3.9
 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)
@@ -66,6 +68,12 @@ Django speaking WFS 2.0 to expose geo data.
 
 For more details, see: <https://django-gisserver.readthedocs.io/>
 
+## Test drive
+
+* Run `docker compose up`.
+* Open http://localhost:8000/ to see this works.
+* Connect to http://localhost:8000/wfs/ in your GIS client (e.g. QGis) and zoom to Amsterdam.
+* Add more data on the map using the Django admin, username and password are both "admin".
 
 ## Quickstart
 
@@ -168,3 +176,5 @@ software developed with public money is also publicly available.
 
 This package is initially developed by the City of Amsterdam, but the tools
 and concepts created in this project can be used in any city.
+
+

django_gisserver-2.0.dist-info/RECORD

@@ -0,0 +1,66 @@
+gisserver/__init__.py,sha256=e6waXF42UPN4o15WEYAQ7DskYjyZB_gs3IANkuyGZUk,38
+gisserver/compat.py,sha256=qmLeT7wGRIyA2ujUtVEuUX7qgr98snak9b5OTvnkhas,451
+gisserver/conf.py,sha256=ppoyVS95mMoQXVbPxPar-tkq1t7fE0J3F6IyKitMWuA,2563
+gisserver/db.py,sha256=G4xF3xd8BQjGbKdf6QpOwzUfnm-phTarS71IRCV0Rys,5385
+gisserver/exceptions.py,sha256=q0EZJrlZ7JPf8tWB9de6fPWX74JBrlsoHYN4pBdCGck,6132
+gisserver/features.py,sha256=b7XrDC8XMn6SK3YdOuC5DvXlral5losrFrCeweecJUM,35744
+gisserver/geometries.py,sha256=Ok9e6fbAhW32iglg6gc955z0ZTN2p2lQd3WlN-FPJho,12338
+gisserver/projection.py,sha256=TStCF9xF4V_aozKqTD8uW9mPofZogobVDpdltXwsyZo,14859
+gisserver/types.py,sha256=5J18OUeL8o0VOdxlMGn7fPja7z4s-9Dgy6G-cjXReZM,41453
+gisserver/views.py,sha256=e7Bqr05FaflXOjOXMfQSix59bHqRmb_ASCRqqJlWqEY,18998
+gisserver/extensions/__init__.py,sha256=MsYUsNsoxxjeDHhx4DW9eGXvmOnI5PkoUXvKxRZaRRw,136
+gisserver/extensions/functions.py,sha256=Gv_IoWgJbCONbGg2P4GXdZDI18GvNtHDWLWQjOQMJLY,9085
+gisserver/extensions/queries.py,sha256=_UNWjHMgGgWtBzOl9Ez587e6WeE1_9uN8Qyjzfi4PMo,9435
+gisserver/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/management/commands/loadgeojson.py,sha256=bdCdt37cKPIYV9cQtLFJ0BzFcVgQQ9y59kTtPX7bYkA,11493
+gisserver/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/operations/base.py,sha256=m56SRTnC6GVWfwugtXgdlIVNh6Vr1h8r_OdfBjWQQ5M,9839
+gisserver/operations/wfs20.py,sha256=WIvGXg1-M01s52VB8nSJGM0tKoviMhnNghQIrfqzudM,24226
+gisserver/output/__init__.py,sha256=5DTFnVEvs-lno_6lOOZheXhF4F96VkwAk71Q5juYe1M,977
+gisserver/output/base.py,sha256=EF3PFUrj2pGzbh2Yt4bpjlwkoGDoI63rHn6wkstXA3g,10303
+gisserver/output/csv.py,sha256=wKtcgwY37NjeLhBxAm2qgKk8UDX-4uUZEzK9LmmVKrQ,6624
+gisserver/output/geojson.py,sha256=fTEB-MRaYLYbJzQVvmZ8ev-Cwrl3lgsR8Jif2zWYSKg,11525
+gisserver/output/gml32.py,sha256=OtBXGup5m1GA9dM_p33E9IXtD-9KcZ58MgMyg-lkGd4,32567
+gisserver/output/iters.py,sha256=YbvtIIy977Snm5m7cYyQext0GCpo8S_u4azTCBNqqgw,8355
+gisserver/output/results.py,sha256=vvwJK1JEgRbs9S4sg5fmsd_avw5ztiC107OizygHk5M,15149
+gisserver/output/stored.py,sha256=m3JcR4MUilyuM_5J6XJDOIyzrhRJbcpg-6FMKy69csc,5763
+gisserver/output/utils.py,sha256=H4lD5Dn_xo8lAHcFv5LjKyj-SNMzzZsZrtDny9HISXk,2671
+gisserver/output/xmlschema.py,sha256=fHj8h9-vG508uRmM-kD5r2omde2wa_myJWWwcWe2lus,6445
+gisserver/parsers/__init__.py,sha256=eGORBeT0F8fR3AadV1uq8dbCeZtIeK0-__CcXwSvXgs,402
+gisserver/parsers/ast.py,sha256=DVUF3977RTjIpsu5yxbKS23Yxepn6JMj1NIUdRmQq2Q,11806
+gisserver/parsers/query.py,sha256=Ndipmq94reShe-DNKwJ96Ig0GdmshRhtVIF6OEGMGeg,6386
+gisserver/parsers/values.py,sha256=7AuOX8Zgb6Cnwb1FuY8Jl0r6TbLrGlNmhICw48sNiCE,2320
+gisserver/parsers/xml.py,sha256=jMsK1enKN0i_rdtjzGqcKdxnr9-n2-9jPY6hX56sU4g,9309
+gisserver/parsers/fes20/__init__.py,sha256=ji0bIRap4fvNW_WWhjnbkBm7ozuEblccIHNzL403Y3E,883
+gisserver/parsers/fes20/expressions.py,sha256=sjBO-S0aQDIorAPg6z7SSUwOreveJEA0w7qcj26UXoA,11275
+gisserver/parsers/fes20/filters.py,sha256=nMAQwgSXl2c7SvVZY_PJSO9XSf55ltvDPnCmIQ5SM9s,6518
+gisserver/parsers/fes20/identifiers.py,sha256=E-6ijz050fjoG-wyzzaIYwxVPplE9RVtoLN_iFNIYw8,3513
+gisserver/parsers/fes20/lookups.py,sha256=nVdqNP0uZntgT1czTxuuUMBVhGKbRsKm8RU-YwGt6EE,5362
+gisserver/parsers/fes20/operators.py,sha256=E5sdepKSxKmklDfHZoNwBwPCqihx5RQJfiA91bv_Hxc,31196
+gisserver/parsers/fes20/sorting.py,sha256=MZXT2RCRKWO9368lkbCbd17IIlTHKuRroafAQVNQuXo,4769
+gisserver/parsers/gml/__init__.py,sha256=DS6CRpFayQp3i5UdwdnAenBb6V6B8vSkn4zQmpo-pBM,1573
+gisserver/parsers/gml/base.py,sha256=hyYAVg-pagH43MFvVgLBzPbIY-uAR1ytDPCtNaXLeww,1165
+gisserver/parsers/gml/geometries.py,sha256=DSBwzjsT16iwSH-bPixLmB5LWpNNUVBL0byl3iMN_Eg,4654
+gisserver/parsers/ows/__init__.py,sha256=0SeM6vfwjWI-WeRD7eS_iN4Jsl8uzXr2yMFpZVHokb4,624
+gisserver/parsers/ows/kvp.py,sha256=et-vlI3EjcK_z1ArGt26RxDyipuwI85NNDe0FVcg7eI,7093
+gisserver/parsers/ows/requests.py,sha256=TZRPX_4RGeNX0qN-OJiRZMGYIWfbn-4vF7zVL4Z1nSk,5496
+gisserver/parsers/wfs20/__init__.py,sha256=6_0TZcLVu48J7Pz802CvkrzEoDDIlI7Bz1t7_VPaOjs,881
+gisserver/parsers/wfs20/adhoc.py,sha256=yM88MrGudYz692QZTL5H6KO1KKZHg0DL44NKWezbYxU,9066
+gisserver/parsers/wfs20/base.py,sha256=_yEIJLrkzPxxj8sjePeSn8PA6L4PTnon5UruDWXejBo,5601
+gisserver/parsers/wfs20/projection.py,sha256=iGpg75VnHj3GrFnSJodEuXbhCF04Phh1IfcAFpurkfw,3930
+gisserver/parsers/wfs20/requests.py,sha256=fl7CUHrqhnEm__M67CHG3hVB9c2r7jFTHJIqlVbW8fI,16756
+gisserver/parsers/wfs20/stored.py,sha256=4YtlildS_lUnY2iZyGQiVQM9TkSjgaaD7iDWtumg82c,7090
+gisserver/static/gisserver/index.css,sha256=h24POXHqJOWtcBRNBFMxZiiknbATRTRWCL6nPyTgPr0,440
+gisserver/templates/gisserver/index.html,sha256=Gq6nasptfquoyd7ihKLtj02tyadijK_Qh8ies6pZxy8,920
+gisserver/templates/gisserver/service_description.html,sha256=y61iVhrcjg44qp-EymaFkUwdsB0LeYTGTbFO0JYOCEs,932
+gisserver/templates/gisserver/wfs/feature_field.html,sha256=Kzbs96GcallCdGLeTPYsFnT6wJ5ar-feyqAmHzJT0u8,587
+gisserver/templates/gisserver/wfs/feature_type.html,sha256=pIfa1cMsTlNIrzNiEOaq9LjzzF7_vZ9C7eN6KDBLOHE,788
+gisserver/templates/gisserver/wfs/2.0.0/get_capabilities.xml,sha256=SGZSn7cDU_Oai6d45xrkqhax5CPyI1oIc8BZLOEw1X4,8695
+gisserver/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/templatetags/gisserver_tags.py,sha256=L2YG-PxiKR0QWBMRLLrL_VR94p6wCb5HzgnrPMg4hug,995
+django_gisserver-2.0.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+django_gisserver-2.0.dist-info/METADATA,sha256=c9OYER5wjNqHxdxWRA3E3F-v5QMDqPvZ-yCM0NRlFMk,6217
+django_gisserver-2.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+django_gisserver-2.0.dist-info/top_level.txt,sha256=8zFCEMmkpixE4TPiOAlxSq3PD2EXvAeFKwG4yZoIIOQ,10
+django_gisserver-2.0.dist-info/RECORD,,

{django_gisserver-1.4.1.dist-info → django_gisserver-2.0.dist-info}/WHEEL

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

gisserver/__init__.py

@@ -1 +1 @@
-__version__ = "1.4.1"  # follows PEP440
+__version__ = "2.0"  # follows PEP440

gisserver/compat.py

@@ -0,0 +1,23 @@
+"""Compatability imports"""
+
+import sys
+
+import django
+from django.conf import settings
+from django.db import models
+
+if (
+    "django.contrib.postgres" in settings.INSTALLED_APPS
+    or "django.contrib.postgres" in sys.modules
+):
+    from django.contrib.postgres.fields import ArrayField
+else:
+    ArrayField = None
+
+GeneratedField = models.GeneratedField if django.VERSION >= (5, 0) else None
+
+
+__all__ = (
+    "ArrayField",
+    "GeneratedField",
+)

gisserver/conf.py

@@ -28,6 +28,13 @@ GISSERVER_SUPPORTED_CRS_ONLY = getattr(settings, "GISSERVER_SUPPORTED_CRS_ONLY",
 # 0 = No counting, 1 = all pages, 2 = only for the first page.
 GISSERVER_COUNT_NUMBER_MATCHED = getattr(settings, "GISSERVER_COUNT_NUMBER_MATCHED", 1)
 
+# -- output rendering
+
+GISSERVER_EXTRA_OUTPUT_FORMATS = getattr(settings, "GISSERVER_EXTRA_OUTPUT_FORMATS", {})
+GISSERVER_GET_FEATURE_OUTPUT_FORMATS = getattr(
+    settings, "GISSERVER_GET_FEATURE_OUTPUT_FORMATS", {}
+)
+
 # -- max page size
 
 # Allow tuning the page size without having to override code.

gisserver/db.py

@@ -2,15 +2,17 @@
 
 from __future__ import annotations
 
+import logging
 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 GeometryXsdElement
+
+logger = logging.getLogger(__name__)
 
 
 class AsEWKT(functions.GeoFunc):
@@ -54,9 +56,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 +67,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,74 +75,75 @@ 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)
 
 
-def conditional_transform(
-    expression: str | functions.GeoFunc, expression_srid: int, output_srid: int
-) -> str | functions.Transform:
-    """Apply a CRS Transform to the queried field if that is needed."""
-    if expression_srid != output_srid:
-        expression = functions.Transform(expression, srid=output_srid)
-    return expression
-
-
-def build_db_annotations(
-    selects: dict[str, str | functions.Func],
-    name_template: str,
-    wrapper_func: type[functions.Func],
-) -> dict:
-    """Utility to build annotations for all geometry fields for an XSD type.
-    This is used by various DB-optimized rendering methods.
-    """
-    return {
-        escape_xml_name(name, name_template): wrapper_func(target)
-        for name, target in selects.items()
-    }
-
+def replace_queryset_geometries(
+    queryset: models.QuerySet,
+    geo_elements: list[GeometryXsdElement],
+    output_crs: CRS,
+    wrapper_func: type[functions.GeoFunc],
+) -> models.QuerySet:
+    """Replace the queryset geometry retrieval with a database-rendered version.
 
-def get_db_annotation(instance: models.Model, name: str, name_template: str):
-    """Retrieve the value that an annotation has added to the model."""
-    # The "name" allows any XML-tag elements, escape the most obvious
-    escaped_name = escape_xml_name(name, name_template)
+    This uses absolute paths in the queryset, but can use relative paths for related querysets.
+    """
+    defer_names = []
+    as_geo_map = {}
+    for geo_element in geo_elements:
+        if geo_element.source is not None:  # excludes GmlBoundedByElement
+            defer_names.append(geo_element.local_orm_path)
+            annotation_name = _as_annotation_name(geo_element.local_orm_path, wrapper_func)
+            as_geo_map[annotation_name] = wrapper_func(
+                get_db_geometry_target(geo_element, output_crs, use_relative_path=True)
+            )
+
+    if not defer_names:
+        return queryset
+
+    logger.debug(
+        "DB rendering: QuerySet for %s replacing %r with %r",
+        queryset.model._meta.label,
+        defer_names,
+        list(as_geo_map.keys()),
+    )
+    return queryset.defer(*defer_names).annotate(**as_geo_map)
+
+
+def get_db_rendered_geometry(
+    instance: models.Model, geo_element: GeometryXsdElement, replacement: type[functions.GeoFunc]
+) -> str:
+    """Retrieve the database-rendered geometry.
+    This includes formatted EWKT or GML output, rendered by the database.
+    """
+    annotation_name = _as_annotation_name(geo_element.local_orm_path, replacement)
     try:
-        return getattr(instance, escaped_name)
+        return getattr(instance, annotation_name)
     except AttributeError as e:
+        prefix = _as_annotation_name("", replacement)
+        available = ", ".join(key for key in instance.__dict__ if key.startswith(prefix)) or "none"
         raise AttributeError(
-            f" DB annotation {instance._meta.model_name}.{escaped_name}"
-            f" not found (using {name_template})"
+            f" DB annotation {instance._meta.label}.{annotation_name} not found. Found {available}."
         ) from e
 
 
 @lru_cache
-def escape_xml_name(name: str, template="{name}") -> str:
+def _as_annotation_name(name: str, func: type[functions.GeoFunc]) -> str:
     """Escape an XML name to be used as annotation name."""
-    return template.format(name=name.replace(".", "_"))
+    return f"_{func.__name__}_{name.replace('.', '_')}"
 
 
-def get_db_geometry_selects(
-    gml_elements: list[XsdElement], 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.
+def get_db_geometry_target(
+    geo_element: GeometryXsdElement, output_crs: CRS, use_relative_path: bool = False
+) -> str | functions.Transform:
+    """Translate a GML geometry field into the proper expression for retrieving it from the database.
+    The path will be wrapped into a CRS Transform function if needed.
     """
-    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
-    }
-
-
-def _get_db_geometry_target(xsd_element: XsdElement, 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)
+    orm_path = geo_element.local_orm_path if use_relative_path else geo_element.orm_path
+    if geo_element.source_srid != output_crs.srid:
+        return functions.Transform(orm_path, srid=output_crs.srid)
+    else:
+        return orm_path

gisserver/exceptions.py

@@ -8,14 +8,37 @@ https://docs.opengeospatial.org/is/09-025r2/09-025r2.html#35
 https://docs.opengeospatial.org/is/09-025r2/09-025r2.html#411
 """
 
+import logging
+from contextlib import contextmanager
+
 from django.conf import settings
+from django.http import HttpResponse
 from django.utils.html import format_html
 
+logger = logging.getLogger(__name__)
+
+
+@contextmanager
+def wrap_parser_errors(name: str, locator: str):
+    """Convert the value into a Python format.
+    This catches any typical exceptions and transforms them into an OWSException.
+    """
+    try:
+        yield
+    except ExternalParsingError as e:
+        raise OperationParsingFailed(
+            f"Unable to parse {name} argument: {e}", locator=locator
+        ) from None
+    except (TypeError, ValueError, NotImplementedError) as e:
+        # TypeError/ValueError are raised by most handlers for unexpected data
+        # The NotImplementedError can be raised by fes parsing.
+        raise InvalidParameterValue(f"Invalid {name} argument: {e}", locator=locator) from None
+
 
 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 +55,31 @@ 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(f"text/locator arguments are switched: {text!r}, locator={locator!r}")
+
         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):
+        logger.debug("Returning HTTP %d for %s: %s", self.status_code, self.code, self.text)
+        xml_body = self.as_xml()
+        return HttpResponse(
+            b'<?xml version="1.0" encoding="UTF-8"?>\n%b' % xml_body.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 +87,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/extensions/__init__.py

@@ -0,0 +1,4 @@
+"""Package that allows third party code to extend the server.
+
+This allows registering extra stored procedures or filter functions.
+"""

gisserver/{parsers/fes20 → extensions}/functions.py

@@ -22,8 +22,14 @@ FesFunctionBody = Union[models.Func, Callable[..., models.Func]]
 
 @dataclass(order=True)
 class FesFunction:
-    """Wrapper that defines a fes function, with type descriptions.
-    This is also used to provide metadata to the GetCapabilities call.
+    """A registered database function that can be used by ``<fes:Function name="...">`.
+
+    The :class:`~gisserver.parsers.fes20.expressions.Function` class will resolve
+    these registered functions by name, and call :meth:`build_query` to include them
+    in the database query. This will actually insert a Django ORM function in the query!
+
+    This wrapper class also provides the metadata and type descriptions of the function,
+    which is exposed in the ``GetCapabilities`` call.
     """
 
     #: Name of the function
@@ -50,7 +56,7 @@ class FesFunction:
 
 
 class FesFunctionRegistry:
-    """Registry of functions to be callable by <fes:Function>.
+    """Registry of functions to be callable by ``<fes:Function>``.
 
     The registered functions should be capable of running an SQL function.
     """
@@ -97,12 +103,12 @@ class FesFunctionRegistry:
             return _wrapper
 
     def resolve_function(self, function_name) -> FesFunction:
-        """Resole the function using it's name."""
+        """Resole the function using its name."""
         try:
             return self.functions[function_name]
         except KeyError:
             raise InvalidParameterValue(
-                "filter", f"Unsupported function: {function_name}"
+                f"Unsupported function: {function_name}", locator="filter"
             ) from None