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

gisserver/output/csv.py

@@ -6,7 +6,6 @@ import csv
 from datetime import datetime, timezone
 from io import StringIO
 
-from django.conf import settings
 from django.db import models
 
 from gisserver import conf
@@ -16,9 +15,9 @@ from gisserver.db import (
     get_db_annotation,
     get_db_geometry_selects,
 )
-from gisserver.features import FeatureType
 from gisserver.geometries import CRS
-from gisserver.types import XsdComplexType, XsdElement
+from gisserver.queries import FeatureProjection
+from gisserver.types import XsdElement
 
 from .base import OutputRenderer
 
@@ -41,7 +40,7 @@ class CSVRenderer(OutputRenderer):
     @classmethod
     def decorate_queryset(
         cls,
-        feature_type: FeatureType,
+        projection: FeatureProjection,
         queryset: models.QuerySet,
         output_crs: CRS,
         **params,
@@ -49,17 +48,15 @@ class CSVRenderer(OutputRenderer):
         """Make sure relations are included with select-related to avoid N-queries.
         Using prefetch_related() isn't possible with .iterator().
         """
-        xsd_type: XsdComplexType = feature_type.xsd_type
-
         # Take all relations that are expanded to complex elements,
         # and all relations that are fetched for flattened elements.
         related = {
             xsd_element.orm_path
-            for xsd_element in xsd_type.complex_elements
+            for xsd_element in projection.complex_elements
             if not xsd_element.is_many
         } | {
             xsd_element.orm_relation[0]
-            for xsd_element in xsd_type.flattened_elements
+            for xsd_element in projection.flattened_elements
             if not xsd_element.is_many
         }
         if related:
@@ -68,11 +65,12 @@ class CSVRenderer(OutputRenderer):
         return queryset
 
     def render_stream(self):
-        output = StringIO()
+        self.output = output = StringIO()
         writer = csv.writer(output, dialect=self.dialect)
 
         is_first_collection = True
         for sub_collection in self.collection.results:
+            projection = sub_collection.projection
             if is_first_collection:
                 is_first_collection = False
             else:
@@ -80,14 +78,18 @@ class CSVRenderer(OutputRenderer):
                 output.write("\n\n")
 
             # Write the header
-            fields = [f for f in sub_collection.feature_type.xsd_type.elements if not f.is_many]
-            writer.writerow(self.get_header(fields))
+            fields = [
+                f
+                for f in projection.xsd_root_elements
+                if not f.is_many and f.xml_name not in ("gml:name", "gml:boundedBy")
+            ]
+            writer.writerow(self.get_header(projection, fields))
 
             # By using .iterator(), the results are streamed with as little memory as
             # possible. Doing prefetch_related() is not possible now. That could only
             # be implemented with cursor pagination for large sets for 1000+ results.
             for instance in sub_collection.iterator():
-                writer.writerow(self.get_row(instance, fields))
+                writer.writerow(self.get_row(instance, projection, fields))
 
                 # Only perform a 'yield' every once in a while,
                 # as it goes back-and-forth for writing it to the client.
@@ -101,37 +103,40 @@ class CSVRenderer(OutputRenderer):
 
     def render_exception(self, exception: Exception):
         """Render the exception in a format that fits with the output."""
-        if settings.DEBUG:
-            return f"\n\n{exception.__class__.__name__}: {exception}\n"
-        else:
-            return f"\n\n{exception.__class__.__name__} during rendering!\n"
+        message = super().render_exception(exception)
+        buffer = self.output.getvalue()
+        return f"{buffer}\n\n{message}\n"
 
-    def get_header(self, fields: list[XsdElement]) -> list[str]:
+    def get_header(
+        self, projection: FeatureProjection, xsd_elements: list[XsdElement]
+    ) -> list[str]:
         """Return all field names."""
         names = []
         append = names.append
-        for field in fields:
-            if field.type.is_complex_type:
+        for xsd_element in xsd_elements:
+            if xsd_element.type.is_complex_type:
                 # Expand complex types
-                for sub_field in field.type.elements:
-                    append(f"{field.name}.{sub_field.name}")
+                for sub_field in projection.xsd_child_nodes[xsd_element]:
+                    append(f"{xsd_element.name}.{sub_field.name}")
             else:
-                append(field.name)
+                append(xsd_element.name)
 
         return names
 
-    def get_row(self, instance: models.Model, fields: list[XsdElement]):
+    def get_row(
+        self, instance: models.Model, projection: FeatureProjection, xsd_elements: list[XsdElement]
+    ):
         """Return all field values for a single row."""
         values = []
         append = values.append
-        for field in fields:
-            if field.is_geometry:
-                append(self.render_geometry(instance, field))
+        for xsd_element in xsd_elements:
+            if xsd_element.is_geometry:
+                append(self.render_geometry(instance, xsd_element))
                 continue
 
-            value = field.get_value(instance)
-            if field.type.is_complex_type:
-                for sub_field in field.type.elements:
+            value = xsd_element.get_value(instance)
+            if xsd_element.type.is_complex_type:
+                for sub_field in projection.xsd_child_nodes[xsd_element]:
                     append(sub_field.get_value(value))
             elif isinstance(value, list):
                 # Array field
@@ -149,22 +154,22 @@ class CSVRenderer(OutputRenderer):
 
 class DBCSVRenderer(CSVRenderer):
     """Further optimized CSV renderer that uses the database to render EWKT.
-    This is about 40% faster then calling the GEOS C-API from python.
+    This is about 40% faster than calling the GEOS C-API from python.
     """
 
     @classmethod
     def decorate_queryset(
         cls,
-        feature_type: FeatureType,
+        projection: FeatureProjection,
         queryset: models.QuerySet,
         output_crs: CRS,
         **params,
     ) -> models.QuerySet:
-        queryset = super().decorate_queryset(feature_type, queryset, output_crs, **params)
+        queryset = super().decorate_queryset(projection, queryset, output_crs, **params)
 
         # Instead of reading the binary geometry data,
         # ask the database to generate EWKT data directly.
-        geo_selects = get_db_geometry_selects(feature_type.xsd_type.geometry_elements, output_crs)
+        geo_selects = get_db_geometry_selects(projection.geometry_elements, output_crs)
         if geo_selects:
             queryset = queryset.defer(*geo_selects.keys()).annotate(
                 **build_db_annotations(geo_selects, "_as_ewkt_{name}", AsEWKT)

gisserver/output/geojson.py

@@ -3,19 +3,17 @@
 from datetime import datetime, timezone
 from decimal import Decimal
 from io import BytesIO
-from typing import cast
 
 import orjson
-from django.conf import settings
 from django.contrib.gis.db.models.functions import AsGeoJSON
 from django.db import models
 from django.utils.functional import Promise
 
 from gisserver import conf
 from gisserver.db import get_db_geometry_target
-from gisserver.features import FeatureType
 from gisserver.geometries import CRS
-from gisserver.types import XsdComplexType
+from gisserver.queries import FeatureProjection
+from gisserver.types import XsdElement
 
 from .base import OutputRenderer
 
@@ -46,18 +44,21 @@ class GeoJsonRenderer(OutputRenderer):
     @classmethod
     def decorate_queryset(
         cls,
-        feature_type: FeatureType,
+        projection: FeatureProjection,
         queryset: models.QuerySet,
         output_crs: CRS,
         **params,
     ):
-        queryset = super().decorate_queryset(feature_type, queryset, output_crs, **params)
+        """Redefine which fields to query, always include geometry, but remove all others"""
+        main_geo_element = projection.feature_type.main_geometry_element
+        projection.add_field(main_geo_element)  # make sure geometry is always queried
+        queryset = super().decorate_queryset(projection, queryset, output_crs, **params)
 
         # Other geometries can be excluded as these are not rendered by 'properties'
         other_geometries = [
-            model_field.name
-            for model_field in feature_type.geometry_fields
-            if model_field is not feature_type.geometry_field
+            gml_element.orm_path
+            for gml_element in projection.geometry_elements
+            if gml_element is not main_geo_element
         ]
         if other_geometries:
             queryset = queryset.defer(*other_geometries)
@@ -65,7 +66,7 @@ class GeoJsonRenderer(OutputRenderer):
         return queryset
 
     def render_stream(self):
-        output = BytesIO()
+        self.output = output = BytesIO()
 
         # Generate the header from a Python dict,
         # but replace the last "}" into a comma, to allow writing more
@@ -78,6 +79,8 @@ class GeoJsonRenderer(OutputRenderer):
         # Flatten the results, they are not grouped in a second FeatureCollection
         is_first_collection = True
         for sub_collection in self.collection.results:
+            projection = sub_collection.projection
+
             if is_first_collection:
                 is_first_collection = False
             else:
@@ -92,7 +95,7 @@ class GeoJsonRenderer(OutputRenderer):
 
                 # The "properties" object is generated by orjson.dumps(),
                 # while the "geometry" object uses the built-in 'GEOSGeometry.json' result.
-                output.write(self.render_feature(sub_collection.feature_type, instance))
+                output.write(self.render_feature(projection, instance))
 
                 # Only perform a 'yield' every once in a while,
                 # as it goes back-and-forth for writing it to the client.
@@ -113,34 +116,27 @@ class GeoJsonRenderer(OutputRenderer):
 
     def render_exception(self, exception: Exception):
         """Render the exception in a format that fits with the output."""
-        if settings.DEBUG:
-            return f"/* {exception.__class__.__name__}: {exception} */\n"
-        else:
-            return f"/* {exception.__class__.__name__} during rendering! */\n"
+        message = super().render_exception(exception)
+        buffer = self.output.getvalue()
+        return f"{buffer}/* {message} */\n"
 
-    def render_feature(self, feature_type: FeatureType, instance: models.Model) -> bytes:
+    def render_feature(self, projection: FeatureProjection, instance: models.Model) -> bytes:
         """Render the output of a single feature"""
 
         # Get all instance attributes:
-        properties = self.get_properties(feature_type, feature_type.xsd_type, instance)
+        properties = self.get_properties(projection, projection.xsd_root_elements, instance)
+        feature_type = projection.feature_type
 
+        # Add the name field
         if feature_type.show_name_field:
             name = feature_type.get_display_value(instance)
-            geometry_name = b'"geometry_name":%b,' % orjson.dumps(name)
+            json_geometry_name = b'"geometry_name":%b,' % orjson.dumps(name)
         else:
-            geometry_name = b""
-
-        return (
-            b"    {"
-            b'"type":"Feature",'
-            b'"id":%b,'
-            b"%b"
-            b'"geometry":%b,'
-            b'"properties":%b'
-            b"}"
-        ) % (
+            json_geometry_name = b""
+
+        return b'    {"type":"Feature","id":%b,%b"geometry":%b,"properties":%b}' % (
             orjson.dumps(f"{feature_type.name}.{instance.pk}"),
-            geometry_name,
+            json_geometry_name,
             self.render_geometry(feature_type, instance),
             orjson.dumps(properties, default=_json_default),
         )
@@ -218,18 +214,19 @@ class GeoJsonRenderer(OutputRenderer):
         return links
 
     def get_properties(
-        self,
-        feature_type: FeatureType,
-        xsd_type: XsdComplexType,
-        instance: models.Model,
+        self, projection: FeatureProjection, xsd_elements: list[XsdElement], instance: models.Model
     ) -> dict:
         """Collect the data for the 'properties' field.
 
         This is based on the original XSD definition,
         so the rendering is consistent with other output formats.
+
+        :param projection: Overview of all fields to render.
+        :param xsd_elements: The XSD elements to render.
+        :param instance: The object instance.
         """
         props = {}
-        for xsd_element in xsd_type.elements:
+        for xsd_element in xsd_elements:
             if not xsd_element.is_geometry:
                 value = xsd_element.get_value(instance)
                 if xsd_element.type.is_complex_type:
@@ -237,21 +234,16 @@ class GeoJsonRenderer(OutputRenderer):
                     if value is None:
                         props[xsd_element.name] = None
                     else:
-                        value_xsd_type = cast(XsdComplexType, xsd_element.type)
+                        sub_elements = projection.xsd_child_nodes[xsd_element]
                         if xsd_element.is_many:
-                            # If the retrieved QuerySet was not filtered yet, do so now.
-                            # This can't be done in get_value() because the FeatureType
-                            # is not known there.
-                            value = feature_type.filter_related_queryset(value)
-
                             # "..._to_many relation; reverse FK, M2M or array field.
                             props[xsd_element.name] = [
-                                self.get_properties(feature_type, value_xsd_type, item)
+                                self.get_properties(projection, sub_elements, item)
                                 for item in value
                             ]
                         else:
                             props[xsd_element.name] = self.get_properties(
-                                feature_type, value_xsd_type, value
+                                projection, sub_elements, value
                             )
                 else:
                     # Scalar value, or list (for ArrayField).
@@ -263,23 +255,23 @@ class GeoJsonRenderer(OutputRenderer):
 class DBGeoJsonRenderer(GeoJsonRenderer):
     """GeoJSON renderer that relays the geometry rendering to the database.
 
-    This is even more efficient then calling the C-API for each feature.
+    This is even more efficient than calling the C-API for each feature.
     """
 
     @classmethod
-    def decorate_queryset(self, feature_type: FeatureType, queryset, output_crs, **params):
+    def decorate_queryset(self, projection: FeatureProjection, queryset, output_crs, **params):
         """Update the queryset to let the database render the GML output.
-        This is far more efficient then GeoDjango's logic, which performs a
+        This is far more efficient than GeoDjango's logic, which performs a
         C-API call for every single coordinate of a geometry.
         """
-        queryset = super().decorate_queryset(feature_type, queryset, output_crs, **params)
+        queryset = super().decorate_queryset(projection, queryset, output_crs, **params)
         # If desired, the entire FeatureCollection could be rendered
         # in PostgreSQL as well: https://postgis.net/docs/ST_AsGeoJSON.html
-        if feature_type.geometry_fields:
-            match = feature_type.resolve_element(feature_type.geometry_field.name)
-            queryset = queryset.defer(feature_type.geometry_field.name).annotate(
+        main_geometry_field = projection.feature_type.main_geometry_element
+        if main_geometry_field is not None:
+            queryset = queryset.defer(main_geometry_field.orm_path).annotate(
                 _as_db_geojson=AsGeoJSON(
-                    get_db_geometry_target(match, output_crs),
+                    get_db_geometry_target(main_geometry_field, output_crs),
                     precision=conf.GISSERVER_DB_PRECISION,
                 )
             )