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

{django_gisserver-1.5.0 → django-gisserver-2.0}/CHANGES.md

@@ -1,10 +1,82 @@
+# 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.
 

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: django-gisserver
-Version: 1.5.0
+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,10 @@ 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>=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.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"
+License-File: LICENSE
 
 [![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 +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
 
@@ -168,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.5.0 → 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.5.0 → django-gisserver-2.0/django_gisserver.egg-info}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: django-gisserver
-Version: 1.5.0
+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,10 @@ 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>=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.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"
+License-File: LICENSE
 
 [![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 +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
 
@@ -168,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.5.0 → 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,36 +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/projection.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-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.5.0 → 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-1.5.0 → django-gisserver-2.0}/gisserver/db.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from functools import lru_cache, reduce
 
 from django.contrib.gis.db.models import functions
@@ -9,7 +10,9 @@ from django.db import connection, connections, models
 
 from gisserver import conf
 from gisserver.geometries import CRS
-from gisserver.types import GmlElement
+from gisserver.types import GeometryXsdElement
+
+logger = logging.getLogger(__name__)
 
 
 class AsEWKT(functions.GeoFunc):
@@ -78,63 +81,69 @@ def get_geometries_union(
         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.
+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.
     """
-    return {
-        escape_xml_name(name, name_template): wrapper_func(target)
-        for name, target in selects.items()
-    }
+    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_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)
+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[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.
+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 {
-        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(gml_element: GmlElement, output_crs: CRS) -> str | functions.Transform:
-    """Wrap the selection of a geometry field in a CRS Transform if needed."""
-    return conditional_transform(
-        gml_element.orm_path, gml_element.source.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

{django_gisserver-1.5.0 → django-gisserver-2.0}/gisserver/exceptions.py

@@ -8,10 +8,32 @@ 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.
@@ -38,7 +60,7 @@ class OWSException(Exception):
     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")
+            raise ValueError(f"text/locator arguments are switched: {text!r}, locator={locator!r}")
 
         super().__init__(text)
         self.locator = locator
@@ -47,8 +69,10 @@ class OWSException(Exception):
         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' % self.as_xml().encode("utf-8"),
+            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,

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.5.0/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.
     """
@@ -102,7 +108,7 @@ class FesFunctionRegistry:
             return self.functions[function_name]
         except KeyError:
             raise InvalidParameterValue(
-                "filter", f"Unsupported function: {function_name}"
+                f"Unsupported function: {function_name}", locator="filter"
             ) from None