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

gisserver/output/__init__.py

@@ -1,10 +1,8 @@
 """All supported output formats"""
 
-from django.utils.functional import classproperty
+from .results import FeatureCollection, SimpleFeatureCollection  # isort: skip (fixes import loops)
 
-from gisserver import conf
-
-from .base import OutputRenderer
+from .base import CollectionOutputRenderer, OutputRenderer
 from .csv import CSVRenderer, DBCSVRenderer
 from .geojson import DBGeoJsonRenderer, GeoJsonRenderer
 from .gml32 import (
@@ -13,11 +11,13 @@ from .gml32 import (
     GML32Renderer,
     GML32ValueRenderer,
 )
-from .results import FeatureCollection, SimpleFeatureCollection
-from .xmlschema import XMLSchemaRenderer
+from .stored import DescribeStoredQueriesRenderer, ListStoredQueriesRenderer
+from .utils import to_qname
+from .xmlschema import XmlSchemaRenderer
 
 __all__ = [
     "OutputRenderer",
+    "CollectionOutputRenderer",
     "FeatureCollection",
     "SimpleFeatureCollection",
     "DBCSVRenderer",
@@ -28,46 +28,8 @@ __all__ = [
     "GeoJsonRenderer",
     "GML32Renderer",
     "GML32ValueRenderer",
-    "XMLSchemaRenderer",
-    "geojson_renderer",
-    "gml32_renderer",
-    "gml32_value_renderer",
+    "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,22 +1,141 @@
 from __future__ import annotations
 
+import logging
 import math
+import typing
+from io import BytesIO, StringIO
 
 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.features import FeatureRelation, FeatureType
-from gisserver.geometries import CRS
-from gisserver.operations.base import WFSMethod
+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 .results import FeatureCollection
+from .utils import render_xmlns_attributes, to_qname
+
+logger = logging.getLogger(__name__)
+
+if typing.TYPE_CHECKING:
+    from gisserver.operations.base import WFSOperation
+    from gisserver.projection import FeatureProjection, FeatureRelation
+
+    from .results import FeatureCollection
 
 
 class OutputRenderer:
+    """Base class for rendering content.
+
+    Note most rendering logic will generally
+    need to use :class:`XmlOutputRenderer` or :class:`ConnectionOutputRenderer`
+    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.
+            # Handover to WSGI server (starts streaming when reading the contents)
+            stream = self._trap_exceptions(stream)
+            return StreamingHttpResponse(
+                streaming_content=stream,
+                content_type=self.content_type,
+                headers=self.get_headers(),
+            )
+
+    def get_headers(self):
+        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}"
+        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.
 
     It receives the collected 'context' data of the WFSMethod.
@@ -26,188 +145,124 @@ class OutputRenderer:
     #: 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,
-        collection: FeatureCollection,
-        output_crs: CRS,
-    ):
+    def __init__(self, operation: WFSOperation, collection: FeatureCollection):
         """
         Receive the collected data to render.
 
-        :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 output_crs: The requested output projection.
+        :param operation: The calling WFS Method (e.g. GetFeature class)
+        :param collection: The collected data for rendering.
         """
-        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
+        self.apply_projection()
 
-    @classmethod
-    def decorate_collection(cls, collection: FeatureCollection, output_crs: CRS, **params):
+    def apply_projection(self):
         """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.feature_type,
-                sub_collection.queryset,
-                output_crs,
-                **params,
+        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(
-                "srsName",
-                f"Feature '{feature_type.name}' does not support SRID {crs.srid}.",
-            )
-
-    @classmethod
     def decorate_queryset(
-        cls,
-        feature_type: FeatureType,
-        queryset: models.QuerySet,
-        output_crs: CRS,
-        **params,
+        self, projection: FeatureProjection, queryset: models.QuerySet
     ) -> 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
+        """
+        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(feature_type, 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)
+        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, feature_type: FeatureType, 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,
         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=self.get_prefetch_queryset(projection, orm_relation),
             )
-            for orm_relation in feature_type.orm_relations
+            for orm_relation in projection.orm_relations
         ]
 
-    @classmethod
     def get_prefetch_queryset(
-        cls,
-        feature_type: FeatureType,
-        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.
         if feature_relation.related_model is None:
             return None
 
-        return 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
+        # This will also apply .only() based on the projection's feature_relation
+        return projection.feature_type.get_related_queryset(feature_relation)
 
     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} -->\n"
+    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! -->\n"
-
-    def render_stream(self):
-        """Implement this in subclasses to implement a custom output format."""
-        raise NotImplementedError()
+            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,
+        }