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

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

@@ -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,12 +29,12 @@ 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: lru-dict>=1.1.7
 Requires-Dist: orjson>=3.9.15
 Provides-Extra: tests
 Requires-Dist: django-environ>=0.4.5; extra == "tests"
@@ -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.5.0.dist-info → django_gisserver-2.0.dist-info}/WHEEL

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

gisserver/__init__.py

@@ -1 +1 @@
-__version__ = "1.5.0"  # 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,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

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,

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.
     """
@@ -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
 
 

gisserver/extensions/queries.py

@@ -0,0 +1,261 @@
+"""Storage and registry for stored queries.
+These definitions follow the WFS spec.
+
+By using the registry, custom stored queries can be registered in this server.
+Out of the box, only the mandatory built-in ``GetFeatureById`` query is present.
+"""
+
+from __future__ import annotations
+
+import typing
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass, field
+from functools import partial
+from xml.etree.ElementTree import Element
+
+from django.db.models import Q
+
+from gisserver.exceptions import InvalidParameterValue, NotFound, OperationNotSupported
+from gisserver.features import FeatureType
+from gisserver.parsers import fes20
+from gisserver.parsers.query import CompiledQuery
+from gisserver.types import XsdTypes
+
+if typing.TYPE_CHECKING:
+    from gisserver.output import SimpleFeatureCollection
+
+__all__ = (
+    "GetFeatureById",
+    "QueryExpressionText",
+    "StoredQueryDescription",
+    "StoredQueryRegistry",
+    "stored_query_registry",
+)
+
+WFS_LANGUAGE = "urn:ogc:def:queryLanguage:OGC-WFS::WFS_QueryExpression"  # body is <wfs:Query>
+FES_LANGUAGE = "urn:ogc:def:queryLanguage:OGC-FES:Filter"  # body is <fes:Filter>
+
+
+@dataclass
+class QueryExpressionText:
+    """Define the body of a stored query.
+
+    This object type is defined in the WFS spec.
+    It may contain a wfs:Query or wfs:StoredQuery element.
+    """
+
+    #: Which types the query will return.
+    return_feature_types: list[str] | None = None
+    #: The internal language of the query. Can be a WFS/FES-filter, or "python"
+    language: str = FES_LANGUAGE
+    #: Whether the implementation_text will be show or hidden from users.
+    is_private: bool = True
+
+    #: Body
+    implementation_text: str | Element | None = None
+
+
+@dataclass
+class StoredQueryDescription:
+    """WFS metadata of a stored query.
+    This is based on the ``<wfs:StoredQueryDescription>`` element,
+    and returned in ``DescribeStoredQueries``.
+
+    While it's possible to define multiple QueryExpressionText nodes
+    as metadata to describe a query, there is still only one implementation.
+    Note there is no 'typeNames=...' parameter for stored queries.
+    Only direct parameters act as input.
+    """
+
+    #: The ID of the query
+    id: str
+    #: User-visible title
+    title: str
+    #: User-visible description
+    abstract: str
+    #: Parameter declaration
+    parameters: dict[str, XsdTypes]
+
+    #: Metadata describing the query body
+    expressions: list[QueryExpressionText] = field(
+        default_factory=lambda: [QueryExpressionText(language=FES_LANGUAGE)]
+    )
+
+    #: Python-based implementation for the query.
+    implementation_class: type[StoredQueryImplementation] = field(init=False, default=None)
+
+
+class StoredQueryImplementation:
+    """A custom stored query.
+
+    This receives the parameters as init arguments,
+    and should implement :meth:`build_query`.
+    The function is registered using ``StoredQueryRegistry.register()``.
+    """
+
+    # Registered metadata
+    _meta: StoredQueryDescription
+
+    # Allow queries to return only the XML nodes, without any <wfs:FeatureCollection> wrapper.
+    has_standalone_output: bool = False
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} implementing '{self._meta.id}'>"
+
+    def bind(self, source_query, feature_types: list[FeatureType]):
+        """Associate this query with the application data."""
+        self.source_query = source_query
+        self.feature_types = feature_types
+        if len(feature_types) > 1:
+            raise OperationNotSupported("Join queries are not supported", locator="typeNames")
+
+    def get_type_names(self) -> list[str]:
+        """Tell which type names this query applies to."""
+        raise NotImplementedError()
+
+    def build_query(self, compiler: CompiledQuery) -> Q | None:
+        """Contribute our filter expression to the internal query.
+
+        This should add the filter expressions to the internal query compiler.
+        The top-level ``<wfs:StoredQuery>`` object will add
+        the ``<wfs:PropertyName>`` logic and other elements.
+        """
+        raise NotImplementedError()
+
+    def finalize_results(self, result: SimpleFeatureCollection):
+        """Hook to allow subclasses to inspect the results."""
+
+
+class StoredQueryRegistry:
+    """Registry of functions to be callable by <wfs:StoredQuery>."""
+
+    def __init__(self):
+        self.stored_queries: dict[str, type(StoredQueryImplementation)] = {}
+
+    def __bool__(self):
+        return bool(self.stored_queries)
+
+    def __iter__(self) -> Iterator[StoredQueryDescription]:
+        return iter(self.stored_queries.values())
+
+    def get_queries(self) -> Iterable[StoredQueryDescription]:
+        """Find all descriptions for stored queries."""
+        return self.stored_queries.values()
+
+    def register(
+        self,
+        meta: StoredQueryDescription | None = None,
+        query_expression: type[StoredQueryImplementation] | None = None,
+        **meta_kwargs,
+    ):
+        """Register a custom class that handles a stored query.
+        This function can be used as decorator or normal call.
+        """
+        if meta is None:
+            meta = StoredQueryDescription(**meta_kwargs)
+        elif meta_kwargs:
+            raise TypeError("Either provide the 'meta' object or 'meta_kwargs'")
+
+        if query_expression is not None:
+            self._register(meta, query_expression)
+            return meta
+        else:
+            return partial(self._register, meta)  # decorator effect.
+
+    def _register(
+        self, meta: StoredQueryDescription, implementation_class: type[StoredQueryImplementation]
+    ):
+        """Internal registration method."""
+        if not issubclass(implementation_class, StoredQueryImplementation):
+            raise TypeError(f"Expecting {StoredQueryImplementation}' subclass")
+        if meta.implementation_class is not None:
+            raise RuntimeError("Can't register same StoredQueryDescription again.")
+
+        # for now link both. There is always a single implementation for the metadata.
+        meta.implementation_class = implementation_class
+        self.stored_queries[meta.id] = meta
+
+    def resolve_query(self, query_id) -> type[StoredQueryDescription]:
+        """Find the stored procedure using the ID."""
+        try:
+            return self.stored_queries[query_id]
+        except KeyError:
+            raise InvalidParameterValue(
+                f"Stored query does not exist: {query_id}",
+                locator="STOREDQUERY_ID",
+            ) from None
+
+
+stored_query_registry = StoredQueryRegistry()
+
+
+@stored_query_registry.register(
+    id="urn:ogc:def:query:OGC-WFS::GetFeatureById",
+    title="Get feature by identifier",
+    abstract="Returns the single feature that corresponds with the ID argument",
+    parameters={"id": XsdTypes.string},
+    expressions=[QueryExpressionText(language=WFS_LANGUAGE)],
+)
+class GetFeatureById(StoredQueryImplementation):
+    """The stored query for GetFeatureById.
+
+    This can be called using::
+
+        <wfs:StoredQuery id="urn:ogc:def:query:OGC-WFS::GetFeatureById">
+            <wfs:Parameter name="ID">typename.ID</wfs:Parameter>
+        </wfs:StoredQuery>
+
+    or using KVP syntax::
+
+        ?...&REQUEST=GetFeature&STOREDQUERY_ID=urn:ogc:def:query:OGC-WFS::GetFeatureById&ID=typename.ID
+
+    The execution of the ``GetFeatureById`` query is essentially the same as::
+
+        <wfs:Query xmlns:wfs='..." xmlns:fes='...'>
+          <fes:Filter><fes:ResourceId rid='{ID}'/></fes:Filter>
+        </wfs:Query>
+
+    or::
+
+        <wfs:Query typeName="{typename}">
+          <fes:Filter>
+            <fes:PropertyIsEqualTo>
+              <fes:ValueReference>{primary-key-field}</fes:ValueReference>
+              <fes:Literal>{ID-value}</fes:Literal>
+            </fes:PropertyIsEqualTo>
+          </fes:Filter>
+        </wfs:Query>
+
+    Except that the response is supposed to contain only the item itself.
+    """
+
+    # Projection of GetFeatureById only returns the document nodes, not a <wfs:FeatureCollection> wrapper
+    has_standalone_output = True
+
+    def __init__(self, id: str, ns_aliases: dict[str, str]):
+        """Initialize the query with the request parameters."""
+        if "." not in id:
+            # Always report this as 404
+            raise NotFound("Expected typeName.id for ID parameter", locator="ID") from None
+
+        # GetFeatureById is essentially a ResourceId lookup, reuse that logic here.
+        self.resource_id = fes20.ResourceId.from_string(id, ns_aliases)
+
+    def get_type_names(self) -> list[str]:
+        """Tell which type names this query applies to."""
+        return [self.resource_id.get_type_name()]
+
+    def build_query(self, compiler: CompiledQuery) -> Q:
+        """Contribute our filter expression to the internal query."""
+        try:
+            return self.resource_id.build_query(compiler)
+        except InvalidParameterValue as e:
+            raise InvalidParameterValue(f"Invalid ID value: {e.__cause__}", locator="ID") from e
+
+    def finalize_results(self, results: SimpleFeatureCollection):
+        """Override to implement 404 checking."""
+        # Directly attempt to collect the data.
+        # Avoid having to do that in the output renderer.
+        if results.first() is None:
+            # WFS 2.0.2: Return NotFound instead of InvalidParameterValue
+            raise NotFound(f"Feature not found with ID {self.resource_id.rid}.", locator="ID")