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

gisserver/output/__init__.py

@@ -1,12 +1,11 @@
-"""All supported output formats"""
+"""The output rendering classes for all response types.
 
-from .results import FeatureCollection, SimpleFeatureCollection  # isort: skip (fixes import loops)
-
-from django.utils.functional import classproperty
+This also includes collection classes for iterating over the Django QuerySet results.
+"""
 
-from gisserver import conf
+from .results import FeatureCollection, SimpleFeatureCollection  # isort: skip (fixes import loops)
 
-from .base import OutputRenderer
+from .base import CollectionOutputRenderer, OutputRenderer, XmlOutputRenderer
 from .csv import CSVRenderer, DBCSVRenderer
 from .geojson import DBGeoJsonRenderer, GeoJsonRenderer
 from .gml32 import (
@@ -15,10 +14,13 @@ from .gml32 import (
     GML32Renderer,
     GML32ValueRenderer,
 )
-from .xmlschema import XMLSchemaRenderer
+from .stored import DescribeStoredQueriesRenderer, ListStoredQueriesRenderer
+from .utils import to_qname
+from .xmlschema import XmlSchemaRenderer
 
 __all__ = [
     "OutputRenderer",
+    "CollectionOutputRenderer",
     "FeatureCollection",
     "SimpleFeatureCollection",
     "DBCSVRenderer",
@@ -29,46 +31,9 @@ __all__ = [
     "GeoJsonRenderer",
     "GML32Renderer",
     "GML32ValueRenderer",
-    "XMLSchemaRenderer",
-    "geojson_renderer",
-    "gml32_renderer",
-    "gml32_value_renderer",
+    "XmlOutputRenderer",
+    "XmlSchemaRenderer",
+    "ListStoredQueriesRenderer",
+    "DescribeStoredQueriesRenderer",
+    "to_qname",
 ]
-
-
-def select_renderer(native_renderer_class, db_renderer_class):
-    """Dynamically select the preferred renderer.
-    This allows changing the settings within the app.
-    """
-
-    class SelectRenderer:
-        """A proxy to the actual rendering class.
-        Its structure still allows accessing class-properties of the actual class.
-        """
-
-        @classproperty
-        def real_class(self):
-            if conf.GISSERVER_USE_DB_RENDERING:
-                return db_renderer_class
-            else:
-                return native_renderer_class
-
-        def __new__(cls, *args, **kwargs):
-            # Return the actual class instead
-            return cls.real_class(*args, **kwargs)
-
-        @classmethod
-        def decorate_collection(cls, *args, **kwargs):
-            return cls.real_class.decorate_collection(*args, **kwargs)
-
-        @classproperty
-        def max_page_size(cls):
-            return cls.real_class.max_page_size
-
-    return SelectRenderer
-
-
-csv_renderer = select_renderer(CSVRenderer, DBCSVRenderer)
-gml32_renderer = select_renderer(GML32Renderer, DBGML32Renderer)
-gml32_value_renderer = select_renderer(GML32ValueRenderer, DBGML32ValueRenderer)
-geojson_renderer = select_renderer(GeoJsonRenderer, DBGeoJsonRenderer)

gisserver/output/base.py

@@ -1,128 +1,222 @@
 from __future__ import annotations
 
+import logging
 import math
 import typing
+from collections.abc import Iterator
+from io import BytesIO, StringIO
+from itertools import chain
 
 from django.conf import settings
 from django.db import models
 from django.http import HttpResponse, StreamingHttpResponse
-from django.utils.html import escape
+from django.http.response import HttpResponseBase  # Django 3.2 import location
 
-from gisserver import conf
-from gisserver.exceptions import InvalidParameterValue
+from gisserver.exceptions import wrap_filter_errors
+from gisserver.features import FeatureType
+from gisserver.parsers.values import fix_type_name
+from gisserver.parsers.xml import split_ns
+from gisserver.types import XsdAnyType, XsdNode
+
+from .utils import render_xmlns_attributes, to_qname
+
+logger = logging.getLogger(__name__)
 
 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 gisserver.operations.base import WFSOperation
+    from gisserver.projection import FeatureProjection, FeatureRelation
 
     from .results import FeatureCollection, SimpleFeatureCollection
 
 
 class OutputRenderer:
-    """Base class to create streaming responses.
+    """Base class for rendering content.
+
+    Note most rendering logic will generally
+    need to use :class:`~gisserver.output.XmlOutputRenderer`
+    or :class:`~gisserver.output.CollectionOutputRenderer` as their base class
+    """
+
+    #: Default content type for the HTTP response
+    content_type = "application/octet-stream"
+
+    def __init__(self, operation: WFSOperation):
+        """Base method for all output rendering."""
+        self.operation = operation
+
+    def get_response(self) -> HttpResponseBase:
+        """Render the output as regular or streaming response."""
+        stream = self.render_stream()
+        if isinstance(stream, (str, bytes, StringIO, BytesIO)):
+            # Not a real stream, output anyway as regular HTTP response.
+            return HttpResponse(
+                content=stream,
+                content_type=self.content_type,
+                headers=self.get_headers(),
+            )
+        else:
+            # An actual generator.
+            # Peek the generator so initial exceptions can still be handled,
+            # and get rendered as normal HTTP responses with the proper status.
+            try:
+                start = next(stream)  # peek, so any raised OWSException here is handled by OWSView
+                stream = chain([start], self._trap_exceptions(stream))
+            except StopIteration:
+                pass
+
+            # Handover to WSGI server (starts streaming when reading the contents)
+            return StreamingHttpResponse(
+                streaming_content=stream,
+                content_type=self.content_type,
+                headers=self.get_headers(),
+            )
+
+    def get_headers(self) -> dict[str, str]:
+        """Override to define HTTP headers to add."""
+        return {}
+
+    def _trap_exceptions(self, stream):
+        """Decorate the generator to show exceptions"""
+        try:
+            yield from stream
+        except Exception as e:
+            # Can't return 500 at this point,
+            # but can still tell the client what happened.
+            yield self.render_exception(e)
+            raise
+
+    def render_exception(self, exception: Exception):
+        """Inform the client that the stream processing was interrupted with an exception.
+        The exception can be rendered in the format fits with the output.
 
-    It receives the collected 'context' data of the WFSMethod.
+        Purposefully, not much information is given, so avoid informing clients.
+        The actual exception is still raised and logged server-side.
+        """
+        if settings.DEBUG:
+            return f"{exception.__class__.__name__}: {exception}"
+        else:
+            return f"{exception.__class__.__name__} during rendering!"
+
+    def render_stream(self):
+        """Implement this in subclasses to implement a custom output format.
+
+        The implementation may return a ``str``/``bytes`` object, which becomes
+        a normal ``HttpResponse`` object **OR** return a generator
+        that emits chunks. Such generator is wrapped in a ``StreamingHttpResponse``.
+        """
+        raise NotImplementedError()
+
+
+class XmlOutputRenderer(OutputRenderer):
+    """Base class/mixin for XML-based rendering.
+
+    This provides the logic to translate XML elements into QName aliases.
     """
 
+    #: Default content type for the HTTP response
+    content_type = "text/xml; charset=utf-8"
+
+    #: Default extra namespaces to include in the xmlns="..." attributes, and use for to_qname().
+    xml_namespaces = {}
+
+    def __init__(self, operation: WFSOperation):
+        """Base method for all output rendering."""
+        super().__init__(operation)
+        self.app_namespaces = {
+            **self.xml_namespaces,
+            **operation.view.get_xml_namespaces_to_prefixes(),
+        }
+
+    def render_xmlns_attributes(self):
+        """Render XML Namespace declaration attributes"""
+        return render_xmlns_attributes(self.app_namespaces)
+
+    def to_qname(self, xsd_type: XsdNode | XsdAnyType, namespaces=None) -> str:
+        """Generate the aliased name for the element or type."""
+        return to_qname(xsd_type.namespace, xsd_type.name, namespaces or self.app_namespaces)
+
+    def feature_to_qname(self, feature_type: FeatureType | str) -> str:
+        """Convert the FeatureType name to a QName"""
+        if isinstance(feature_type, FeatureType):
+            return to_qname(feature_type.xml_namespace, feature_type.name, self.app_namespaces)
+        else:
+            # e.g. "return_type" for StoredQueryDescription/QueryExpressionText
+            type_name = fix_type_name(feature_type, self.operation.view.xml_namespace)
+            ns, localname = split_ns(type_name)
+            return to_qname(ns, localname, self.app_namespaces)
+
+
+class CollectionOutputRenderer(OutputRenderer):
+    """Base class to create streaming responses."""
+
     #: Allow to override the maximum page size.
     #: This value can be 'math.inf' to support endless pages by default.
     max_page_size = None
 
-    #: Define the content type for rendering the output
-    content_type = "application/octet-stream"
-
     #: An optional content-disposition header to output
     content_disposition = None
 
-    def __init__(
-        self,
-        method: WFSMethod,
-        source_query: QueryExpression,
-        collection: FeatureCollection,
-        output_crs: CRS,
-    ):
+    def __init__(self, operation: WFSOperation, collection: FeatureCollection):
         """
         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.
+        :param operation: The calling WFS Operation (e.g. GetFeature class)
         :param collection: The collected data for rendering.
-        :param projection: Which fields to render.
-        :param output_crs: The requested output projection.
         """
-        self.method = method
-        self.source_query = source_query
+        super().__init__(operation)
         self.collection = collection
-        self.output_crs = output_crs
-        self.xml_srs_name = escape(str(self.output_crs))
-
-        # Common elements for output rendering:
-        self.server_url = method.view.server_url
-        self.app_xml_namespace = method.view.xml_namespace
-
-    @classmethod
-    def decorate_collection(cls, collection: FeatureCollection, output_crs: CRS, **params):
-        """Perform presentation-layer logic enhancements on the queryset."""
-        for sub_collection in collection.results:
-            # Validate the presentation-level parameters for this feature:
-            cls.validate(sub_collection.feature_type, **params)
-
-            queryset = cls.decorate_queryset(
-                sub_collection.projection,
-                sub_collection.queryset,
-                output_crs,
-                **params,
+        self.apply_projection()
+
+    def apply_projection(self):
+        """Perform presentation-layer logic enhancements on all results.
+        This calls :meth:`decorate_queryset` for
+        each :class:`~gisserver.output.SimpleFeatureCollection`.
+        """
+        for sub_collection in self.collection.results:
+            queryset = self.decorate_queryset(
+                projection=sub_collection.projection,
+                queryset=sub_collection.queryset,
             )
+            if sub_collection._result_cache is not None:
+                raise RuntimeError(
+                    "SimpleFeatureCollection QuerySet was already processed in output rendering."
+                )
             if queryset is not None:
                 sub_collection.queryset = queryset
 
-    @classmethod
-    def validate(cls, feature_type: FeatureType, **params):
-        """Validate the presentation parameters"""
-        crs = params["srsName"]
-        if (
-            conf.GISSERVER_SUPPORTED_CRS_ONLY
-            and crs is not None
-            and crs not in feature_type.supported_crs
-        ):
-            raise InvalidParameterValue(
-                f"Feature '{feature_type.name}' does not support SRID {crs.srid}.",
-                locator="srsName",
-            )
-
-    @classmethod
     def decorate_queryset(
-        cls,
-        projection: FeatureProjection,
-        queryset: models.QuerySet,
-        output_crs: CRS,
-        **params,
+        self, projection: FeatureProjection, queryset: models.QuerySet
     ) -> models.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 projection: The projection information, including feature that is being rendered.
         :param queryset: The constructed queryset so far.
-        :param output_crs: The projected output
-        :param params: All remaining request parameters (e.g. KVP parameters).
         """
+        if queryset._result_cache is not None:
+            raise RuntimeError(
+                "QuerySet was already processed before passing to the output rendering."
+            )
+
         # Avoid fetching relations, fetch these within the same query,
-        related = cls._get_prefetch_related(projection, output_crs)
-        if related:
-            queryset = queryset.prefetch_related(*related)
+        prefetches = self._get_prefetch_related(projection)
+        if prefetches:
+            logger.debug(
+                "QuerySet for %s prefetches: %r",
+                queryset.model._meta.label,
+                [p.prefetch_through for p in prefetches],
+            )
+            queryset = queryset.prefetch_related(*prefetches)
 
+        logger.debug(
+            "QuerySet for %s only retrieves: %r",
+            queryset.model._meta.label,
+            projection.only_fields,
+        )
         return queryset.only("pk", *projection.only_fields)
 
-    @classmethod
-    def _get_prefetch_related(
-        cls,
-        projection: FeatureProjection,
-        output_crs: CRS,
-    ) -> list[models.Prefetch]:
+    def _get_prefetch_related(self, projection: FeatureProjection) -> list[models.Prefetch]:
         """Summarize which fields read data from relations.
 
         This combines the input from flattened and complex fields,
@@ -134,17 +228,13 @@ class OutputRenderer:
         return [
             models.Prefetch(
                 orm_relation.orm_path,
-                queryset=cls.get_prefetch_queryset(projection, orm_relation, output_crs),
+                queryset=self.get_prefetch_queryset(projection, orm_relation),
             )
             for orm_relation in projection.orm_relations
         ]
 
-    @classmethod
     def get_prefetch_queryset(
-        cls,
-        projection: FeatureProjection,
-        feature_relation: FeatureRelation,
-        output_crs: CRS,
+        self, projection: FeatureProjection, feature_relation: FeatureRelation
     ) -> models.QuerySet | None:
         """Generate a custom queryset that's used to prefetch a relation."""
         # Multiple elements could be referencing the same model, just take first that is filled in.
@@ -154,76 +244,40 @@ class OutputRenderer:
         # 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."""
-        stream = self.render_stream()
-        if isinstance(stream, (str, bytes)):
-            # Not a real stream, output anyway as regular HTTP response.
-            response = HttpResponse(content=stream, content_type=self.content_type)
-        else:
-            # A actual generator.
-            stream = self._trap_exceptions(stream)
-            response = StreamingHttpResponse(
-                streaming_content=stream,
-                content_type=self.content_type,
-            )
-
-        # Add HTTP headers
-        for name, value in self.get_headers().items():
-            response[name] = value
-
-        # Handover to WSGI server (starts streaming when reading the contents)
-        return response
-
     def get_headers(self):
         """Return the response headers"""
         if self.content_disposition:
             # Offer a common quick content-disposition logic that works for all possible queries.
-            sub_collection = self.collection.results[0]
-            if sub_collection.stop == math.inf:
-                page = f"{sub_collection.start}-end" if sub_collection.start else "all"
-            elif sub_collection.stop:
-                page = f"{sub_collection.start}-{sub_collection.stop - 1}"
-            else:
-                page = "results"
-
             return {
                 "Content-Disposition": self.content_disposition.format(
-                    typenames="+".join(sub.feature_type.name for sub in self.collection.results),
-                    page=page,
-                    date=self.collection.date.strftime("%Y-%m-%d %H.%M.%S%z"),
-                    timestamp=self.collection.timestamp,
+                    **self.get_content_disposition_kwargs()
                 )
             }
 
         return {}
 
-    def _trap_exceptions(self, stream):
-        """Decorate the generator to show exceptions"""
-        try:
-            yield from stream
-        except Exception as e:
-            # Can't return 500 at this point,
-            # but can still tell the client what happened.
-            yield self.render_exception(e)
-            raise
-
-    def render_exception(self, exception: Exception):
-        """Inform the client that the stream processing was interrupted with an exception.
-        The exception can be rendered in the format fits with the output.
-
-        Purposefully, not much information is given, so avoid informing clients.
-        The actual exception is still raised and logged server-side.
-        """
-        if settings.DEBUG:
-            return f"{exception.__class__.__name__}: {exception}"
+    def get_content_disposition_kwargs(self) -> dict:
+        """Offer a common quick content-disposition logic that works for all possible queries."""
+        sub_collection = self.collection.results[0]
+        if sub_collection.stop == math.inf:
+            page = f"{sub_collection.start}-end" if sub_collection.start else "all"
+        elif sub_collection.stop:
+            page = f"{sub_collection.start}-{sub_collection.stop - 1}"
         else:
-            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)
+            page = "results"
+
+        return {
+            "typenames": "+".join(
+                feature_type.name
+                for sub in self.collection.results
+                for feature_type in sub.feature_types
+            ),
+            "page": page,
+            "date": self.collection.date.strftime("%Y-%m-%d %H.%M.%S%z"),
+            "timestamp": self.collection.timestamp,
+        }
+
+    def read_features(self, sub_collection: SimpleFeatureCollection) -> Iterator[models.Model]:
+        """A wrapper to read features from a collection, while raising WFS exceptions on query errors."""
+        with wrap_filter_errors(sub_collection.source_query):
+            yield from sub_collection