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

gisserver/operations/base.py

@@ -32,12 +32,12 @@ RE_SAFE_FILENAME = re.compile(r"\A[A-Za-z0-9]+[A-Za-z0-9.]*")  # no dot at the s
 
 @dataclass(frozen=True)
 class Parameter:
-    """The definition of an parameter for an WFS method.
+    """The definition of a parameter for an WFS method.
 
     These parameters should be defined in the
     WFSMethod parameters attribute / get_parameters().
 
-    These fields is used to parse the incoming request.
+    These fields are used to parse the incoming request.
     The GetCapabilities method also reads the metadata of this value.
     """
 
@@ -81,9 +81,9 @@ class Parameter:
             if not self.required:
                 return self.default
             elif value is None:
-                raise MissingParameterValue(self.name, f"Missing {kvp_name} parameter")
+                raise MissingParameterValue(f"Missing {kvp_name} parameter", locator=self.name)
             else:
-                raise InvalidParameterValue(self.name, f"Empty {kvp_name} parameter")
+                raise InvalidParameterValue(f"Empty {kvp_name} parameter", locator=self.name)
 
         # Allow conversion into a python object
         if self.parser is not None:
@@ -91,13 +91,15 @@ class Parameter:
                 value = self.parser(value)
             except ExternalParsingError as e:
                 raise OperationParsingFailed(
-                    self.name, f"Unable to parse {kvp_name} argument: {e}"
+                    f"Unable to parse {kvp_name} argument: {e}",
+                    locator=self.name,
                 ) 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(
-                    self.name, f"Invalid {kvp_name} argument: {e}"
+                    f"Invalid {kvp_name} argument: {e}",
+                    locator=self.name,
                 ) from None
 
         # Validate against value choices
@@ -111,14 +113,16 @@ class Parameter:
         """
         if self.allowed_values is not None and value not in self.allowed_values:
             msg = self.error_messages.get("invalid", "Invalid value for {name}: {value}")
-            raise InvalidParameterValue(self.name, msg.format(name=self.name, value=value))
+            raise InvalidParameterValue(msg.format(name=self.name, value=value), locator=self.name)
 
 
 class UnsupportedParameter(Parameter):
     def value_from_query(self, KVP: dict):
         kvp_name = self.name.upper()
         if kvp_name in KVP:
-            raise InvalidParameterValue(self.name, f"Support for {self.name} is not implemented!")
+            raise InvalidParameterValue(
+                f"Support for {self.name} is not implemented!", locator=self.name
+            )
         return None
 
 
@@ -134,6 +138,7 @@ class OutputFormat:
         renderer_class=None,
         max_page_size=None,
         title=None,
+        in_capabilities=True,
         **extra,
     ):
         """
@@ -141,7 +146,8 @@ class OutputFormat:
         :param renderer_class: The class that performs the output rendering.
             If it's not given, the operation renders it's output using an XML template.
         :param max_page_size: Used to override the ``max_page_size`` of the renderer_class.
-        :param title: A human-friendly name for a HTML overview page.
+        :param title: A human-friendly name for an HTML overview page.
+        :param in_capabilities: Whether this format needs to be advertised in GetCapabilities.
         :param extra: Any additional key-value pairs for the definition.
             Could include ``subtype`` as a shorter alias for the MIME-type.
         """
@@ -150,6 +156,7 @@ class OutputFormat:
         self.subtype = self.extra.get("subtype")
         self.renderer_class = renderer_class
         self.title = title
+        self.in_capabilities = in_capabilities
         self._max_page_size = max_page_size
 
     def matches(self, value):
@@ -197,7 +204,7 @@ class WFSMethod:
 
     do_not_call_in_templates = True  # avoid __call__ execution in Django templates
 
-    #: List the suported parameters for this method, extended by get_parameters()
+    #: List the supported parameters for this method, extended by get_parameters()
     parameters: list[Parameter] = []
 
     #: List the supported output formats for this method.
@@ -258,20 +265,20 @@ class WFSMethod:
 
     def _parse_output_format(self, value) -> OutputFormat:
         """Select the proper OutputFormat object based on the input value"""
-        # When using ?OUTPUTFORMAT=application/gml+xml", it is actually an URL-encoded space
-        # character. Hence spaces are replaced back to a '+' character to allow such notation
-        # instead of forcing it to to be ?OUTPUTFORMAT=application/gml%2bxml".
+        # When using ?OUTPUTFORMAT=application/gml+xml", it is actually a URL-encoded space
+        # character. Hence, spaces are replaced back to a '+' character to allow such notation
+        # instead of forcing it to be ?OUTPUTFORMAT=application/gml%2bxml".
         for v in {value, value.replace(" ", "+")}:
             for o in self.output_formats:
                 if o.matches(v):
                     return o
         raise InvalidParameterValue(
-            "outputformat",
             f"'{value}' is not a permitted output format for this operation.",
+            locator="outputformat",
         ) from None
 
     def _parse_namespaces(self, value) -> dict[str, str]:
-        """Parse the namespaces definition.
+        """Parse the 'namespaces' definition.
 
         The NAMESPACES parameter defines which namespaces are used in the KVP request.
         When this parameter is not given, the default namespaces are assumed.
@@ -287,7 +294,9 @@ class WFSMethod:
         tokens = iter(tokens)
         for prefix in tokens:
             if not prefix.startswith("xmlns("):
-                raise InvalidParameterValue("namespaces", f"Expected xmlns(...) format: {value}")
+                raise InvalidParameterValue(
+                    f"Expected xmlns(...) format: {value}", locator="namespaces"
+                )
             if prefix.endswith(")"):
                 # xmlns(http://...)
                 prefix = ""
@@ -296,7 +305,8 @@ class WFSMethod:
                 uri = next(tokens, "")
                 if not uri.endswith(")"):
                     raise InvalidParameterValue(
-                        "namespaces", f"Expected xmlns(prefix,uri) format: {value}"
+                        f"Expected xmlns(prefix,uri) format: {value}",
+                        locator="namespaces",
                     )
                 prefix = prefix[6:]
                 uri = uri[:-1]
@@ -361,12 +371,12 @@ class WFSMethod:
         )
 
     def _get_xml_template_name(self):
-        """Generate the XML template name for this operation, and check it's file pattern"""
+        """Generate the XML template name for this operation, and check its file pattern"""
         service = self.view.KVP["SERVICE"].lower()
         template_name = f"gisserver/{service}/{self.view.version}/{self.xml_template_name}"
 
         # Since 'service' and 'version' are based on external input,
-        # these values are double checked again to avoid remove file inclusion.
+        # these values are double-checked again to avoid remove file inclusion.
         if not RE_SAFE_FILENAME.match(service) or not RE_SAFE_FILENAME.match(self.view.version):
             raise SuspiciousOperation(f"Refusing to render template name {template_name}")
 
@@ -403,8 +413,8 @@ class WFSTypeNamesMethod(WFSMethod):
             # This allows to perform multiple queries in a single request:
             # TYPENAMES=(A)(B)&FILTER=(filter for A)(filter for B)
             raise OperationParsingFailed(
-                "typenames",
                 "Parameter lists to perform multiple queries are not supported yet.",
+                locator="typenames",
             )
 
         return [self._parse_type_name(name, locator="typenames") for name in type_names.split(",")]
@@ -419,9 +429,9 @@ class WFSTypeNamesMethod(WFSMethod):
             return self.all_feature_types_by_name[local_name]
         except KeyError:
             raise InvalidParameterValue(
-                locator,
                 f"Typename '{name}' doesn't exist in this server. "
                 f"Please check the capabilities and reformulate your request.",
+                locator=locator,
             ) from None
 
 

gisserver/operations/wfs20.py

@@ -44,11 +44,17 @@ RE_SAFE_FILENAME = re.compile(r"\A[A-Za-z0-9]+[A-Za-z0-9.]*")  # no dot at the s
 
 
 class GetCapabilities(WFSMethod):
-    """ "This operation returns map features, and available operations this WFS server supports."""
+    """This operation returns map features, and available operations this WFS server supports."""
 
     output_formats = [
-        OutputFormat("application/gml+xml", version="3.2", title="GML"),  # for FME
         OutputFormat("text/xml"),
+        OutputFormat(
+            # for FME (Feature Manipulation Engine)
+            "application/gml+xml",
+            version="3.2",
+            title="GML",
+            in_capabilities=False,
+        ),
     ]
     xml_template_name = "get_capabilities.xml"
 
@@ -87,16 +93,17 @@ class GetCapabilities(WFSMethod):
         if "VERSION" in self.view.KVP:
             # Even GetCapabilities can still receive a VERSION argument to fixate it.
             raise InvalidParameterValue(
-                "AcceptVersions", "Can't provide both ACCEPTVERSIONS and VERSION"
+                "Can't provide both ACCEPTVERSIONS and VERSION",
+                locator="AcceptVersions",
             )
 
         matched_versions = set(accept_versions.split(",")).intersection(self.view.accept_versions)
         if not matched_versions:
             allowed = ", ".join(self.view.accept_versions)
             raise VersionNegotiationFailed(
-                "acceptversions",
                 f"'{accept_versions}' does not contain supported versions, "
                 f"supported are: {allowed}.",
+                locator="acceptversions",
             )
 
         # Take the highest version (mapserver returns first matching)
@@ -115,7 +122,7 @@ class GetCapabilities(WFSMethod):
     def get_context_data(self, **params):
         view = self.view
 
-        # The 'service' is not reaad from 'params' to avoid dependency on get_parameters()
+        # The 'service' is not read from 'params' to avoid dependency on get_parameters()
         service = view.KVP["SERVICE"]  # is WFS
         service_operations = view.accept_operations[service]
         feature_output_formats = service_operations["GetFeature"].output_formats
@@ -138,18 +145,19 @@ class GetCapabilities(WFSMethod):
 
 class DescribeFeatureType(WFSTypeNamesMethod):
     """This returns an XML Schema for the provided objects.
-    Each feature is exposed as an XSD definition with it's fields.
+    Each feature is exposed as an XSD definition with its fields.
     """
 
     output_formats = [
         OutputFormat("XMLSCHEMA", renderer_class=output.XMLSchemaRenderer),
-        # At least one version of FME seems to sends a DescribeFeatureType
-        # request with this output format. Do what mapserver does and just
-        # send it XML Schema.
+        # At least one version of FME (Feature Manipulation Engine) seems to
+        # send a DescribeFeatureType request with this GML as output format.
+        # Do what mapserver does and just send it XML Schema.
         OutputFormat(
             "application/gml+xml",
             version="3.2",
             renderer_class=output.XMLSchemaRenderer,
+            in_capabilities=False,
         ),
         # OutputFormat("text/xml", subtype="gml/3.1.1"),
     ]
@@ -157,7 +165,7 @@ class DescribeFeatureType(WFSTypeNamesMethod):
     def get_context_data(self, typeNames, **params):
         if self.view.KVP.get("TYPENAMES") == "" or self.view.KVP.get("TYPENAME") == "":
             # Using TYPENAMES= does result in an error.
-            raise MissingParameterValue("typeNames", "Empty TYPENAMES parameter")
+            raise MissingParameterValue("Empty TYPENAMES parameter", locator="typeNames")
         elif typeNames is None:
             # Not given, all types are returned
             typeNames = self.all_feature_types
@@ -218,7 +226,7 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
         # StandardInputParameters
         Parameter("srsName", parser=CRS.from_string),
         # Projection clause parameters
-        UnsupportedParameter("propertyName"),  # which fields to return
+        Parameter("propertyName", parser=fes20.parse_property_name),
         # AdHoc Query parameters
         Parameter("bbox", parser=BoundingBox.from_string),
         Parameter(
@@ -239,7 +247,7 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
 
         try:
             if resultType == "HITS":
-                collection = self.get_hits(query)
+                collection = query.get_hits()
             elif resultType == "RESULTS":
                 # Validate StandardPresentationParameters
                 collection = self.get_paginated_results(query, **params)
@@ -248,16 +256,17 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
         except ExternalParsingError as e:
             # Bad input data
             self._log_filter_error(query, logging.ERROR, e)
-            raise OperationParsingFailed(self._get_locator(**params), str(e)) from e
+            raise OperationParsingFailed(str(e), locator=self._get_locator(**params)) from e
         except ExternalValueError as e:
             # Bad input data
             self._log_filter_error(query, logging.ERROR, e)
-            raise InvalidParameterValue(self._get_locator(**params), str(e)) from e
+            raise InvalidParameterValue(str(e), locator=self._get_locator(**params)) from e
         except ValidationError as e:
             # Bad input data
             self._log_filter_error(query, logging.ERROR, e)
             raise OperationParsingFailed(
-                self._get_locator(**params), "\n".join(map(str, e.messages))
+                "\n".join(map(str, e.messages)),
+                locator=self._get_locator(**params),
             ) from e
         except FieldError as e:
             # e.g. doing a LIKE on a foreign key, or requesting an unknown field.
@@ -265,7 +274,8 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
                 raise
             self._log_filter_error(query, logging.ERROR, e)
             raise InvalidParameterValue(
-                self._get_locator(**params), "Internal error when processing filter"
+                "Internal error when processing filter",
+                locator=self._get_locator(**params),
             ) from e
         except (InternalError, ProgrammingError) as e:
             # e.g. comparing datetime against integer
@@ -274,14 +284,15 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
             logger.exception("WFS request failed: %s\nParams: %r", str(e), params)
             msg = str(e)
             locator = "srsName" if "Cannot find SRID" in msg else self._get_locator(**params)
-            raise InvalidParameterValue(locator, f"Invalid request: {msg}") from e
+            raise InvalidParameterValue(f"Invalid request: {msg}", locator=locator) from e
         except (TypeError, ValueError) as e:
             # TypeError/ValueError could reference a datatype mismatch in an
             # ORM query, but it could also be an internal bug. In most cases,
             # this is already caught by XsdElement.validate_comparison().
             if self._is_orm_error(e):
                 raise InvalidParameterValue(
-                    self._get_locator(**params), f"Invalid filter query: {e}"
+                    f"Invalid filter query: {e}",
+                    locator=self._get_locator(**params),
                 ) from e
             raise
 
@@ -289,40 +300,35 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
         if not output_crs and collection.results:
             output_crs = collection.results[0].feature_type.crs
 
-        # These become init kwargs for the selected OutputRenderer class:
         return {
+            # These become init kwargs for the selected OutputRenderer class:
             "source_query": query,
             "collection": collection,
             "output_crs": output_crs,
         }
 
     def get_query(self, **params) -> queries.QueryExpression:
-        """Create the query object that will process this request"""
+        """Create or retrieve the query object that will process this request.
+
+        This can either retrieve the stored procedure (e.g. from a database),
+        or construct an ad-hoc query from request parameters.
+        """
         if params["STOREDQUERY_ID"]:
             # The 'StoredQueryParameter' already parses the input into a complete object.
             # When it's not provided, the regular Adhoc-query will be created from the KVP request.
             query = params["STOREDQUERY_ID"]
+            query.bind(
+                # TODO: pass this in a cleaner way?
+                all_feature_types=self.all_feature_types_by_name,  # for GetFeatureById
+                value_reference=params.get("valueReference"),  # for GetPropertyValue
+                property_names=params.get("propertyName"),  # for GetFeature with PropertyName
+            )
         else:
-            query = queries.AdhocQuery.from_kvp_request(**params)
-
-        # TODO: pass this in a cleaner way?
-        query.bind(
-            all_feature_types=self.all_feature_types_by_name,  # for GetFeatureById
-            value_reference=params.get("valueReference"),  # for GetPropertyValue
-        )
+            query = queries.AdhocQuery.from_kvp_request(index=0, **params)
+            query.bind(all_feature_types=self.all_feature_types_by_name)
 
         return query
 
-    def get_hits(self, query: queries.QueryExpression) -> output.FeatureCollection:
-        """Return the number of hits"""
-        return query.get_hits()
-
-    def get_results(
-        self, query: queries.QueryExpression, start, count
-    ) -> output.FeatureCollection:
-        """Return the actual results"""
-        return query.get_results(start, count=count)
-
     def get_paginated_results(
         self, query: queries.QueryExpression, outputFormat, **params
     ) -> output.FeatureCollection:
@@ -336,7 +342,7 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
         stop = start + page_size
 
         # Perform query
-        collection = self.get_results(query, start=start, count=page_size)
+        collection = query.get_results(start, count=page_size)
 
         # Allow presentation-layer to add extra logic.
         if outputFormat.renderer_class is not None:

gisserver/output/__init__.py

@@ -1,5 +1,7 @@
 """All supported output formats"""
 
+from .results import FeatureCollection, SimpleFeatureCollection  # isort: skip (fixes import loops)
+
 from django.utils.functional import classproperty
 
 from gisserver import conf
@@ -13,7 +15,6 @@ from .gml32 import (
     GML32Renderer,
     GML32ValueRenderer,
 )
-from .results import FeatureCollection, SimpleFeatureCollection
 from .xmlschema import XMLSchemaRenderer
 
 __all__ = [

gisserver/output/base.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import math
+import typing
 
 from django.conf import settings
 from django.db import models
@@ -9,11 +10,14 @@ from django.utils.html import escape
 
 from gisserver import conf
 from gisserver.exceptions import InvalidParameterValue
-from gisserver.features import FeatureRelation, FeatureType
-from gisserver.geometries import CRS
-from gisserver.operations.base import WFSMethod
 
-from .results import FeatureCollection
+if typing.TYPE_CHECKING:
+    from gisserver.features import FeatureType
+    from gisserver.geometries import CRS
+    from gisserver.operations.base import WFSMethod
+    from gisserver.queries import FeatureProjection, FeatureRelation, QueryExpression
+
+    from .results import FeatureCollection, SimpleFeatureCollection
 
 
 class OutputRenderer:
@@ -35,17 +39,18 @@ class OutputRenderer:
     def __init__(
         self,
         method: WFSMethod,
-        source_query,
+        source_query: QueryExpression,
         collection: FeatureCollection,
         output_crs: CRS,
     ):
         """
         Receive the collected data to render.
+        These parameters are received from the ``get_context_data()`` method of the view.
 
         :param method: The calling WFS Method (e.g. GetFeature class)
         :param source_query: The query that generated this output.
-        :type source_query: gisserver.queries.QueryExpression
-        :param collection: The collected data for rendering
+        :param collection: The collected data for rendering.
+        :param projection: Which fields to render.
         :param output_crs: The requested output projection.
         """
         self.method = method
@@ -66,7 +71,7 @@ class OutputRenderer:
             cls.validate(sub_collection.feature_type, **params)
 
             queryset = cls.decorate_queryset(
-                sub_collection.feature_type,
+                sub_collection.projection,
                 sub_collection.queryset,
                 output_crs,
                 **params,
@@ -84,54 +89,60 @@ class OutputRenderer:
             and crs not in feature_type.supported_crs
         ):
             raise InvalidParameterValue(
-                "srsName",
                 f"Feature '{feature_type.name}' does not support SRID {crs.srid}.",
+                locator="srsName",
             )
 
     @classmethod
     def decorate_queryset(
         cls,
-        feature_type: FeatureType,
+        projection: FeatureProjection,
         queryset: models.QuerySet,
         output_crs: CRS,
         **params,
     ) -> models.QuerySet:
-        """Apply presentation layer logic to the queryset."""
+        """Apply presentation layer logic to the queryset.
+
+        This allows fine-tuning the queryset for any special needs of the output rendering type.
+
+        :param feature_type: The feature that is being queried.
+        :param queryset: The constructed queryset so far.
+        :param output_crs: The projected output
+        :param params: All remaining request parameters (e.g. KVP parameters).
+        """
         # Avoid fetching relations, fetch these within the same query,
-        related = cls._get_prefetch_related(feature_type, output_crs)
+        related = cls._get_prefetch_related(projection, output_crs)
         if related:
             queryset = queryset.prefetch_related(*related)
 
-        # Also limit the queryset to the actual fields that are shown.
-        # No need to request more data
-        fields = [
-            f.orm_field
-            for f in feature_type.xsd_type.elements
-            if not f.is_many or f.is_array  # exclude M2M, but include ArrayField
-        ]
-        return queryset.only("pk", *fields)
+        return queryset.only("pk", *projection.only_fields)
 
     @classmethod
     def _get_prefetch_related(
-        cls, feature_type: FeatureType, output_crs: CRS
+        cls,
+        projection: FeatureProjection,
+        output_crs: CRS,
     ) -> list[models.Prefetch]:
         """Summarize which fields read data from relations.
 
         This combines the input from flattened and complex fields,
         in the unlikely case both variations are used in the same feature.
         """
+        # When PROPERTYNAME is used, determine all ORM paths (and levels) that this query will touch.
+        # The prefetch will only be applied when its field coincide with this list.
+
         return [
             models.Prefetch(
                 orm_relation.orm_path,
-                queryset=cls.get_prefetch_queryset(feature_type, orm_relation, output_crs),
+                queryset=cls.get_prefetch_queryset(projection, orm_relation, output_crs),
             )
-            for orm_relation in feature_type.orm_relations
+            for orm_relation in projection.orm_relations
         ]
 
     @classmethod
     def get_prefetch_queryset(
         cls,
-        feature_type: FeatureType,
+        projection: FeatureProjection,
         feature_relation: FeatureRelation,
         output_crs: CRS,
     ) -> models.QuerySet | None:
@@ -140,7 +151,8 @@ class OutputRenderer:
         if feature_relation.related_model is None:
             return None
 
-        return feature_type.get_related_queryset(feature_relation)
+        # This will also apply .only() based on the projection's feature_relation
+        return projection.feature_type.get_related_queryset(feature_relation)
 
     def get_response(self):
         """Render the output as streaming response."""
@@ -204,10 +216,14 @@ class OutputRenderer:
         The actual exception is still raised and logged server-side.
         """
         if settings.DEBUG:
-            return f"<!-- {exception.__class__.__name__}: {exception} -->\n"
+            return f"{exception.__class__.__name__}: {exception}"
         else:
-            return f"<!-- {exception.__class__.__name__} during rendering! -->\n"
+            return f"{exception.__class__.__name__} during rendering!"
 
     def render_stream(self):
         """Implement this in subclasses to implement a custom output format."""
         raise NotImplementedError()
+
+    def get_projection(self, sub_collection: SimpleFeatureCollection) -> FeatureProjection:
+        """Provide the projection clause for the given sub-collection."""
+        return self.source_query.get_projection(sub_collection.feature_type)