django-gisserver 1.4.1__tar.gz → 2.0__tar.gz

{django-gisserver-1.4.1 → django-gisserver-2.0}/CHANGES.md

@@ -1,3 +1,85 @@
+# 2024-04-28 (2.0)
+
+* Added support for XML POST requests.
+* Added support for geometry elements on child nodes.
+* Added support for Django 5 `GeneratedField` fields as geometry field.
+* Added `WFSView.check_permissions()` API to simplify permission checking.
+* Added `WFSView.xml_namespace_aliases` attribute to configure custom namespace prefixes.
+* Added example app and docker-compose setup for testing.
+* Added `GISSERVER_EXTRA_OUTPUT_FORMATS` setting to define additional output formats.
+* Added `GISSERVER_GET_FEATURE_OUTPUT_FORMATS` setting to override the default output formats.
+* Added `CRS84` and `WEB_MERCATOR` constants in `gisserver.geometries`.
+* Improved debugging by adding debug-level logging and better error messages.
+* Improved font styling somewhat for browsable HTML pages.
+* Fixed XML namespace support (e.g. handling `<ValueReference>ns0:tagname</ValueReference>`).
+* Fixed bugs found by CITE compliance testing:
+  * Support `<fes:PropertyIsLike>` for array elements.
+  * Support `<fes:PropertyIsNil>` for geometry elements.
+  * Support `resulttype=hits` with `count` arguments.
+* Fixed `ArrayField` detection when `django.contrib.postgres` is not in `INSTALLED_APPS`.
+* Fixed `main_geometry_element` detection.
+* Fixed swapped X/Y coordinates for systems that use a different axis-ordering (e.g. EPSG:3879 for Finland).
+* Fixed GeoJSON CRS value to be `CRS84` (urn:ogc:def:crs:OGC::CRS84) instead of WGS84 (urn:ogc:def:crs:EPSG::4326).
+* Fixed applying the `CRS.backend` when the client requests a custom coordinate system using `srsName`.
+* Fixed rendering JSON exceptions during streaming errors.
+* Fixed internal XML Schema; use proper model CamelCasing for class names (doesn't affect requests).
+* Fixed internal XML schema; remove unneeded inheritance from `gml:AbstractFeatureType` for nested elements.
+* Fixed CI testing.
+* Confirmed support for Python 3.13.
+
+This release has a lot of API changes, renamed and moved classes,
+which was needed to implement POST support and XML namespace handling.
+
+This won't affect most projects as they use the basic `FeatureType` functionality.
+For implementations that have taken full advantage of our architecture,
+the notable API changes are:
+
+* Configuration:
+  * `WFSOperation.output_formats` still works, but `get_output_formats()` is preferred.
+  * `WFSOperation.parameters` is replaced by ``get_parameters()`` and only lists parameters that need to be mentioned in `GetCapabilities`.
+  * The `Parameter` class only exposes choices, parsing happens in `gisserver.parsers.wfs20` now.
+  * `FeatureType.xml_namespace` now defines which namespace the feature exists in (defaults to `WFSView.xml_namespace`).
+* Overiding and extending queries:
+  * `FeatureType.get_extent()` was replaced with ``GmlBoundedByElement.get_value()``.
+  * `gisserver.operations`: renamed `WFSMethod` -> `WFSOperation`.
+  * `gisserver.extensions.functions` now tracks filter function registration.
+  * `gisserver.extensions.queries` now tracks stored query registration.
+  * The `StoredQuery` base class is now `StoredQueryImplementation` providing a `build_query()` method.
+  * The internal `CompiledQuery` moved to `gisserver.parsers.query` and receives a `feature_types` array now with a single element.
+   (This change reflects the WFS spec and allowing to potentially implement JOIN queries later).
+* Request parsing:
+  * `WFSView.ows_request` and `request.ows_request` both provide access to the parsed WFS request.
+  * `WFSOperation.parser_class` allows to define a custom parser for a additional WFS operations.
+  * The WFS request parsing moved to `gisserver.parsers.wfs20`, which builds an Abstract Syntax Tree (AST) of the XML request.
+  * The GET request (KVP format) parsing is now a special-case of the XML-based parsing classes.
+* Output formats:
+  * `gisserver.output` no longer exposes the auto-switching DB/non-DB rendering aliases, as `get_output_formats()` can do that easier.
+  * `OutputRenderer` only provides the basic XML aliasing, a new `CollectionOutputRenderer` base class provides the collection logic.
+  * `OutputRenderer.xml_namespaces` allows defining XML namespace aliases that construct default `xmlns` attributes.
+  * All rendering parameters (e.g. output CRS) moved to the `FeatureProjection` logic.
+  * The `decorate_queryset()` logic is no longer a classmethod.
+* Internal XSD schema elements:
+  * XML tag parsing is reworked for simplicity and namespace handling.
+  * Namespace aliases/prefixes are removed entirely, and resolved during rendering.
+  * `FeatureType.xml_name` now returns the full XML name, not the QName.
+  * `XsdTypes` use fully qualified XML names, not the QName.
+  * `XsdElement.xml_name` now returns the full XML name, not the QName.
+  * `XsdElement.is_geometry` was unneeded, use `XsdElement.type.is_geometry` now.
+  * `XsdElement.orm_path` points to the absolute path, and `XsdElement.local_orm_path` to the relative path.
+
+
+# 2024-11-25 (1.5.0)
+
+* Added `PROPERTYNAME` support
+* Added rendering of `<wfs:truncatedResponse>` when errors happen during output streaming.
+* Fixed accessing a feature with 3 geometry fields (fixed our PostgreSQL `ST_Union` syntax).
+* Make sure Django 4.1+ won't do double prefetches on relations that we prefetch.
+* Hide the erroneous output formats in `GetCapabilities` that are supported for FME.
+* Bump requirements to non-vulnerable versions (of lxml and orjson).
+* Improved documentation.
+* Cleaned up code, removing some internal methods.
+* Cleaned up leftover Python 3.7 compat code.
+
 # 2024-08-29 (1.4.1)
 
 * Fix 500 error when `model_attribute` points to a dotted-path.
@@ -197,7 +279,7 @@ for their work on this release.
 # 2020-06-29 (0.8.1)
 
 * Added unpaginated GeoJSON support (performance is good enough).
-* Added basic support for non-namespaced `FILTER` queries, and `PropertyName` tags (though being WFS2 attributes, clients still use them).
+* Added basic support for non-namespaced `FILTER` queries, and `PropertyName` tags (though being WFS1 attributes, clients still use them).
 * Added extra strict check that `ValueReference`/`Literal`/`ResourceId` nodes don't have child nodes.
 * Fixed allowing filtering on unknown or undefined fields (XPaths are now resolved to known elements).
 * Optimized results streaming by automatically using a queryset-iterator if possible.

{django-gisserver-1.4.1/django_gisserver.egg-info → django-gisserver-2.0}/PKG-INFO

@@ -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,7 +29,7 @@ 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
 Provides-Extra: tests
 License-File: LICENSE
@@ -56,6 +58,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
 
@@ -158,3 +166,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-1.4.1 → django-gisserver-2.0}/README.md

@@ -22,6 +22,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
 

{django-gisserver-1.4.1 → django-gisserver-2.0/django_gisserver.egg-info}/PKG-INFO

@@ -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,7 +29,7 @@ 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
 Provides-Extra: tests
 License-File: LICENSE
@@ -56,6 +58,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
 
@@ -158,3 +166,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-1.4.1 → django-gisserver-2.0}/django_gisserver.egg-info/SOURCES.txt

@@ -11,13 +11,21 @@ django_gisserver.egg-info/not-zip-safe
 django_gisserver.egg-info/requires.txt
 django_gisserver.egg-info/top_level.txt
 gisserver/__init__.py
+gisserver/compat.py
 gisserver/conf.py
 gisserver/db.py
 gisserver/exceptions.py
 gisserver/features.py
 gisserver/geometries.py
+gisserver/projection.py
 gisserver/types.py
 gisserver/views.py
+gisserver/extensions/__init__.py
+gisserver/extensions/functions.py
+gisserver/extensions/queries.py
+gisserver/management/__init__.py
+gisserver/management/commands/__init__.py
+gisserver/management/commands/loadgeojson.py
 gisserver/operations/__init__.py
 gisserver/operations/base.py
 gisserver/operations/wfs20.py
@@ -26,35 +34,40 @@ gisserver/output/base.py
 gisserver/output/csv.py
 gisserver/output/geojson.py
 gisserver/output/gml32.py
+gisserver/output/iters.py
 gisserver/output/results.py
+gisserver/output/stored.py
 gisserver/output/utils.py
 gisserver/output/xmlschema.py
 gisserver/parsers/__init__.py
-gisserver/parsers/base.py
-gisserver/parsers/tags.py
+gisserver/parsers/ast.py
+gisserver/parsers/query.py
 gisserver/parsers/values.py
+gisserver/parsers/xml.py
 gisserver/parsers/fes20/__init__.py
 gisserver/parsers/fes20/expressions.py
 gisserver/parsers/fes20/filters.py
-gisserver/parsers/fes20/functions.py
 gisserver/parsers/fes20/identifiers.py
+gisserver/parsers/fes20/lookups.py
 gisserver/parsers/fes20/operators.py
-gisserver/parsers/fes20/query.py
 gisserver/parsers/fes20/sorting.py
 gisserver/parsers/gml/__init__.py
 gisserver/parsers/gml/base.py
 gisserver/parsers/gml/geometries.py
-gisserver/queries/__init__.py
-gisserver/queries/adhoc.py
-gisserver/queries/base.py
-gisserver/queries/stored.py
+gisserver/parsers/ows/__init__.py
+gisserver/parsers/ows/kvp.py
+gisserver/parsers/ows/requests.py
+gisserver/parsers/wfs20/__init__.py
+gisserver/parsers/wfs20/adhoc.py
+gisserver/parsers/wfs20/base.py
+gisserver/parsers/wfs20/projection.py
+gisserver/parsers/wfs20/requests.py
+gisserver/parsers/wfs20/stored.py
 gisserver/static/gisserver/index.css
 gisserver/templates/gisserver/index.html
 gisserver/templates/gisserver/service_description.html
 gisserver/templates/gisserver/wfs/feature_field.html
 gisserver/templates/gisserver/wfs/feature_type.html
-gisserver/templates/gisserver/wfs/2.0.0/describe_stored_queries.xml
 gisserver/templates/gisserver/wfs/2.0.0/get_capabilities.xml
-gisserver/templates/gisserver/wfs/2.0.0/list_stored_queries.xml
 gisserver/templatetags/__init__.py
 gisserver/templatetags/gisserver_tags.py

{django-gisserver-1.4.1 → django-gisserver-2.0}/django_gisserver.egg-info/requires.txt

@@ -1,12 +1,12 @@
 Django>=3.2
 defusedxml>=0.6.0
 lru_dict>=1.1.7
-orjson>=2.4.0
+orjson>=3.9.15
 
 [tests]
 django-environ>=0.4.5
 psycopg2-binary>=2.8.4
-lxml>=4.5.0
+lxml>=4.9.1
 pytest>=6.2.3
 pytest-django>=4.1.0
 pytest-cov>=2.11.1

django-gisserver-2.0/gisserver/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.0"  # follows PEP440

django-gisserver-2.0/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",
+)

{django-gisserver-1.4.1 → django-gisserver-2.0}/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.

django-gisserver-2.0/gisserver/db.py

@@ -0,0 +1,149 @@
+"""Internal module for additional GIS database functions."""
+
+from __future__ import annotations
+
+import logging
+from functools import lru_cache, reduce
+
+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 GeometryXsdElement
+
+logger = logging.getLogger(__name__)
+
+
+class AsEWKT(functions.GeoFunc):
+    """Generate EWKT in the database (PostGIS tested only at the moment)."""
+
+    name = "AsEWKT"
+    output_field = models.TextField()
+
+    def __init__(self, field, precision=conf.GISSERVER_DB_PRECISION, **extra):
+        if connection.ops.spatial_version >= (3, 1):
+            super().__init__(field, precision, **extra)
+        else:
+            super().__init__(field, **extra)
+
+
+class AsGML(functions.AsGML):
+    name = "AsGML"
+
+    def __init__(
+        self,
+        expression,
+        version=3,
+        precision=conf.GISSERVER_DB_PRECISION,
+        envelope=False,
+        **extra,
+    ):
+        # Note that Django's AsGml, version=2, precision=8
+        # the options is postgres-only.
+        super().__init__(expression, version, precision, **extra)
+        self.envelope = envelope
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        # Fill options parameter (https://postgis.net/docs/ST_AsGML.html)
+        options = 33 if self.envelope else 1  # 32 = bbox, 1 = long CRS urn
+        template = f"%(function)s(%(expressions)s, {options})"
+        return self.as_sql(compiler, connection, template=template, **extra_context)
+
+
+class ST_Union(functions.Union):
+    name = "Union"
+    arity = None
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        # 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])"
+        return self.as_sql(compiler, connection, **extra_context)
+
+
+def get_geometries_union(
+    expressions: list[str | functions.GeoFunc], using="default"
+) -> str | functions.Union:
+    """Generate a union of multiple geometry fields."""
+    if not expressions:
+        raise ValueError("Missing geometry fields for get_geometries_union()")
+
+    if len(expressions) == 1:
+        return next(iter(expressions))  # fastest in set data type
+    elif len(expressions) == 2:
+        return functions.Union(*expressions)
+    elif connections[using].vendor == "postgresql":
+        # postgres can handle multiple field names
+        return ST_Union(*expressions)
+    else:
+        # other databases do Union(Union(1, 2), 3)
+        return reduce(functions.Union, expressions)
+
+
+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.
+
+    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, 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.label}.{annotation_name} not found. Found {available}."
+        ) from e
+
+
+@lru_cache
+def _as_annotation_name(name: str, func: type[functions.GeoFunc]) -> str:
+    """Escape an XML name to be used as annotation name."""
+    return f"_{func.__name__}_{name.replace('.', '_')}"
+
+
+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.
+    """
+    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

{django-gisserver-1.4.1 → django-gisserver-2.0}/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 ""
             ),
         )

django-gisserver-2.0/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.
+"""

{django-gisserver-1.4.1/gisserver/parsers/fes20 → django-gisserver-2.0/gisserver/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