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

gisserver/parsers/fes20/sorting.py

@@ -1,18 +1,31 @@
+"""The FES elements that handle sorting."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum
 
 from gisserver.exceptions import InvalidParameterValue
+from gisserver.parsers.ast import AstNode, expect_children, expect_tag, tag_registry
 from gisserver.parsers.fes20 import ValueReference
+from gisserver.parsers.ows import KVPRequest
+from gisserver.parsers.query import CompiledQuery
+from gisserver.parsers.xml import NSElement, xmlns
+
+FES_SORT_ORDER = xmlns.fes20.qname("SortOrder")
 
 
 class SortOrder(Enum):
+    #: Ascending order
     ASC = ""
+    #: Descrending order
     DESC = "-"
 
-    # Support WFS 1 names for clients that still use this.
+    # Support WFS 1 names for clients that still use this:
+
+    #: WFS 1 name that clients still use for ascending.
     A = ASC
+    #: WFS 1 name that clients still use for descending.
     D = DESC
 
     @classmethod
@@ -24,52 +37,118 @@ class SortOrder(Enum):
                 "Expect ASC/DESC ordering direction", locator="sortby"
             ) from None
 
+    @classmethod
+    @expect_tag(xmlns.fes20, "SortOrder")
+    def from_xml(cls, element: NSElement):
+        return SortOrder.from_string(element.text)
+
 
 @dataclass
-class SortProperty:
-    """This class name is based on the WFS spec."""
+@tag_registry.register("SortProperty", xmlns.fes20)
+class SortProperty(AstNode):
+    """This class name is based on the WFS spec.
+
+    This parses and handles the syntax::
+
+        <fes:SortProperty>
+            <fes:ValueReference>name</fes:ValueReference>
+            <fes:SortOrder>ASC</fes:SortOrder>
+        </fes:SortProperty>
+    """
 
     value_reference: ValueReference
     sort_order: SortOrder = SortOrder.ASC
 
+    def __post_init__(self):
+        if "[" in self.value_reference.xpath:
+            raise InvalidParameterValue(
+                "Sorting with XPath attribute selectors is not supported.", locator="sortby"
+            )
+
+    @classmethod
+    @expect_tag(xmlns.fes20, "SortProperty")
+    @expect_children(1, ValueReference, FES_SORT_ORDER)
+    def from_xml(cls, element: NSElement) -> SortProperty:
+        """Parse the incoming XML"""
+        sort_order = element.find(FES_SORT_ORDER)
+        return cls(
+            value_reference=ValueReference.from_xml(element[0]),
+            sort_order=(
+                SortOrder.from_xml(sort_order) if sort_order is not None else SortOrder.ASC
+            ),
+        )
+
+    @classmethod
+    def from_string(cls, value: str, ns_aliases: dict[str, str]) -> SortProperty:
+        """Parse the incoming GET parameter."""
+        xpath, _, direction = value.partition(" ")
+        return SortProperty(
+            value_reference=ValueReference(xpath, ns_aliases),
+            sort_order=SortOrder.from_string(direction) if direction else SortOrder.ASC,
+        )
+
+    def as_kvp(self):
+        """Translate the POST request into KVP GET parameters. This is needed for pagination."""
+        if self.sort_order == SortOrder.ASC:
+            return self.value_reference.xpath
+        else:
+            return f"{self.value_reference.xpath} {self.sort_order.name}"
+
 
 @dataclass
-class SortBy:
-    """The sortBy clause."""
+@tag_registry.register("SortBy", xmlns.fes20)
+class SortBy(AstNode):
+    """The sortBy clause.
+
+    This parses and handles the syntax::
+
+        <fes:SortBy>
+            <fes:SortProperty>
+                <fes:ValueReference>name</fes:ValueReference>
+                <fes:SortOrder>ASC</fes:SortOrder>
+            </fes:SortProperty>
+        </fes:SortBy>
 
+    It also supports the SORTBY parameter for GET requests.
+    """
+
+    #: The ``<fes:SortProperty>`` elements.
     sort_properties: list[SortProperty]
 
     @classmethod
-    def from_string(cls, value: str):
-        """Construct the SortBy object from a KVP "SORTBY" parameter."""
-        props = []
-        for field in value.split(","):
-            if "[" in field:
-                raise InvalidParameterValue(
-                    "sortby", "Sorting with XPath attribute selectors is not supported."
-                )
-
-            if " " in field:
-                xpath, direction = field.split(" ", 1)
-                props.append(
-                    SortProperty(
-                        value_reference=ValueReference(xpath),
-                        sort_order=SortOrder.from_string(direction),
-                    )
-                )
-            else:
-                props.append(SortProperty(value_reference=ValueReference(field)))
-
-        return cls(sort_properties=props)
-
-    def build_ordering(self, feature_type=None) -> list[str]:
+    @expect_children(1, SortProperty)
+    def from_xml(cls, element: NSElement) -> SortBy:
+        """Parse the XML tag."""
+        return cls(
+            sort_properties=[
+                # The from_xml() validates that the child node is a <fes:SortProperty>
+                SortProperty.from_xml(child)
+                for child in element
+            ]
+        )
+
+    @classmethod
+    def from_kvp_request(cls, kvp: KVPRequest) -> SortBy | None:
+        """Construct the SortBy object from a KVP "SORTBY" parameter, and considering NAMESPACES."""
+        value = kvp.get_str("SortBy", default=None)
+        if value is None:
+            return None
+
+        return cls(
+            sort_properties=[
+                SortProperty.from_string(field, kvp.ns_aliases) for field in value.split(",")
+            ]
+        )
+
+    def as_kvp(self) -> str:
+        """Translate the POST request into KVP GET parameters. This is needed for pagination."""
+        return ",".join(sort_property.as_kvp() for sort_property in self.sort_properties)
+
+    def build_ordering(self, compiler: CompiledQuery):
         """Build the ordering for the Django ORM call."""
         ordering = []
         for prop in self.sort_properties:
-            if feature_type is not None:
-                orm_path = prop.value_reference.parse_xpath(feature_type).orm_path
-            else:
-                orm_path = prop.value_reference.xpath.replace("/", "__")
-
+            orm_path = prop.value_reference.parse_xpath(compiler.feature_types).orm_path
             ordering.append(f"{prop.sort_order.value}{orm_path}")
-        return ordering
+
+        compiler.add_ordering(ordering)

gisserver/parsers/gml/__init__.py

@@ -1,54 +1,46 @@
-"""Generic support for various GML versions.
+"""Additional parsing logic for GML values.
 
-These functions locate GML objects, and redirect to the proper parser.
+Most GML elements are parsed through GeoDjango by using the GEOSGeometry element.
 """
 
 from __future__ import annotations
 
-from xml.etree.ElementTree import Element
-
-from defusedxml.ElementTree import fromstring
-
 from gisserver.exceptions import ExternalParsingError
-from gisserver.parsers.base import tag_registry
+from gisserver.parsers.ast import tag_registry
+from gisserver.parsers.xml import NSElement, parse_xml_from_string
 
 from .base import AbstractGeometry, GM_Envelope, GM_Object, TM_Object
-from .geometries import is_gml_element  # also do tag registration
-
-# All known root nodes as GML object:
-FES_GML_NODES = (GM_Object, GM_Envelope, TM_Object)
+from .geometries import GEOSGMLGeometry, is_gml_element  # also do tag registration
 
 __all__ = [
     "GM_Object",
     "GM_Envelope",
     "TM_Object",
     "AbstractGeometry",
+    "GEOSGMLGeometry",
     "parse_gml",
     "parse_gml_node",
     "find_gml_nodes",
 ]
 
 
-def parse_gml(text: str | bytes) -> FES_GML_NODES:
+def parse_gml(text: str | bytes) -> GM_Object | GM_Envelope | TM_Object:
     """Parse an XML <gml:...> string."""
-    root_element = fromstring(text)
+    root_element = parse_xml_from_string(text)
     return parse_gml_node(root_element)
 
 
-def parse_gml_node(element: Element) -> FES_GML_NODES:
-    """Parse the element"""
+def parse_gml_node(element: NSElement) -> GM_Object | GM_Envelope | TM_Object:
+    """Parse the GML element."""
     if not is_gml_element(element):
         raise ExternalParsingError(f"Expected GML namespace for {element.tag}")
 
-    return tag_registry.from_child_xml(element, allowed_types=FES_GML_NODES)
-
+    # All known root nodes as GML object:
+    return tag_registry.node_from_xml(element, allowed_types=(GM_Object, GM_Envelope, TM_Object))
 
-def find_gml_nodes(element: Element) -> list[Element]:
-    """Find all gml elements in a node"""
-    result = []
-    for child in element:
-        # This selects all GML elements, including 2.1
-        if is_gml_element(child):
-            result.append(child)
 
-    return result
+def find_gml_nodes(element: NSElement) -> list[NSElement]:
+    """Find all ``<gml:...>`` elements in a node.
+    This selects all GML elements, including GML 2.1 tags.
+    """
+    return [child for child in element if is_gml_element(child)]

gisserver/parsers/gml/base.py

@@ -4,28 +4,37 @@ See "Table D.2" in the GML 3.2.1 spec, showing how the UML names
 map to the GML implementations. These names are referenced by the FES spec.
 """
 
-from gisserver.parsers.base import BaseNode
+from __future__ import annotations
 
+from gisserver.parsers.ast import AstNode
+from gisserver.parsers.query import CompiledQuery
 
-class AbstractGeometry(BaseNode):
-    """Abstract base classes for all GML objects, regardless of their version.
+__all__ = (
+    "GM_Object",
+    "GM_Envelope",
+    "TM_Object",
+    "AbstractTimeObject",
+    "AbstractTimePrimitive",
+    "Envelope",
+    "AbstractGeometry",
+)
 
-    <gml:AbstractGeometry> implements the ISO 19107 GM_Object.
-    """
 
-    def build_rhs(self, compiler):
-        # Allow the value to be used in a binary operator
+class GM_Object(AstNode):
+    """Abstract base classes for all GML objects, regardless of their version."""
+
+    def build_rhs(self, compiler: CompiledQuery):
+        """Required function to implement.
+        This allows using the value to be used in a binary operator.
+        """
         raise NotImplementedError()
 
 
-class Envelope(BaseNode):
-    """Abstract base classes for all GML objects, regardless of their version.
+class GM_Envelope(AstNode):
+    """Abstract base classes for the GML envelope, regardless of their version."""
 
-    <gml:Envelope> implements ISO 19107 GM_Envelope (see D.2.3.4 and ISO 19107:2003, 6.4.3).
-    """
 
-
-class TM_Object(BaseNode):
+class TM_Object(AstNode):
     """Abstract base classes for temporal GML objects, regardless of their version.
 
     See ISO 19108 TM_Object (see D.2.5.2 and ISO 19108:2002, 5.2.2)
@@ -33,5 +42,17 @@ class TM_Object(BaseNode):
 
 
 # Instead of polluting the MRO with unneeded base classes, create aliases:
-GM_Object = AbstractGeometry
-GM_Envelope = Envelope
+
+#: The ``<gml:AbstractGeometry>`` definition implements the ISO 19107 GM_Object.
+AbstractGeometry = GM_Object
+
+#: The ``<gml:Envelope>`` implements ISO 19107 GM_Envelope (see D.2.3.4 and ISO 19107:2003, 6.4.3).
+Envelope = GM_Envelope
+
+# See https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.1.0/temporal_xsd.html
+
+#: The base class for all time objects
+AbstractTimeObject = TM_Object
+
+#: The base classes for time primitives.
+AbstractTimePrimitive = AbstractTimeObject

gisserver/parsers/gml/geometries.py

@@ -4,16 +4,18 @@ Overview of GML 3.2 changes: https://mapserver.org/el/development/rfc/ms-rfc-105
 """
 
 from dataclasses import dataclass
-from xml.etree.ElementTree import Element, tostring
+from xml.etree.ElementTree import tostring
 
-from django.contrib.gis.geos import GEOSGeometry
+from django.contrib.gis.gdal import AxisOrder
+from django.contrib.gis.geos import GEOSGeometry, Polygon
 
-from gisserver.geometries import CRS
-from gisserver.parsers.base import tag_registry
-from gisserver.parsers.tags import get_attribute
-from gisserver.types import GML21, GML32
+from gisserver.crs import CRS
+from gisserver.exceptions import ExternalParsingError
+from gisserver.parsers.ast import tag_registry
+from gisserver.parsers.query import CompiledQuery
+from gisserver.parsers.xml import NSElement, xmlns
 
-from .base import AbstractGeometry, TM_Object
+from .base import AbstractGeometry, AbstractTimePrimitive
 
 _ANY_GML_NS = "{http://www.opengis.net/gml/"
 
@@ -24,18 +26,20 @@ def is_gml_element(element) -> bool:
 
 
 @dataclass(repr=False)
-@tag_registry.register("Polygon", GML21)
-@tag_registry.register("LineString", GML32)
-@tag_registry.register("LinearRing", GML32)
-@tag_registry.register("MultiLineString", GML32)
-@tag_registry.register("MultiPoint", GML32)
-@tag_registry.register("MultiPolygon", GML32)
-@tag_registry.register("MultiSurface", GML32)
-@tag_registry.register("Point", GML32)
-@tag_registry.register("Polygon", GML32)
-@tag_registry.register("Envelope", GML32)
+@tag_registry.register("Polygon", xmlns.gml21)
+@tag_registry.register("LineString", xmlns.gml32)
+@tag_registry.register("LinearRing", xmlns.gml32)
+@tag_registry.register("MultiLineString", xmlns.gml32)
+@tag_registry.register("MultiPoint", xmlns.gml32)
+@tag_registry.register("MultiPolygon", xmlns.gml32)
+@tag_registry.register("MultiSurface", xmlns.gml32)
+@tag_registry.register("Point", xmlns.gml32)
+@tag_registry.register("Polygon", xmlns.gml32)
+@tag_registry.register("Envelope", xmlns.gml32)
 class GEOSGMLGeometry(AbstractGeometry):
-    """Convert the incoming GML into a Django GEOSGeometry"""
+    """Convert the incoming GML into a Django GEOSGeometry.
+    This tag parses all ``<gml:...>`` geometry elements within the query.
+    """
 
     # Not implemented:
     # - Curve
@@ -43,30 +47,54 @@ class GEOSGMLGeometry(AbstractGeometry):
     # - MultiGeometry
     # - Surface
 
-    xml_ns = ...
-
     srs: CRS
     geos_data: GEOSGeometry
 
     @classmethod
-    def from_xml(cls, element: Element):
+    def from_bbox(cls, bbox_value: str):
+        """Parse the bounding box from an input string.
+
+        It can either be 4 coordinates, or 4 coordinates with a special reference system.
+        """
+        bbox = bbox_value.split(",")
+        if not (4 <= len(bbox) <= 5):
+            raise ExternalParsingError(
+                f"Input does not contain bounding box, expected 4 or 5 values, not {bbox}."
+            )
+
+        polygon = Polygon.from_bbox(
+            (float(bbox[0]), float(bbox[1]), float(bbox[2]), float(bbox[3]))
+        )
+        if len(bbox) == 5:
+            crs = CRS.from_string(bbox[4])
+            polygon.srid = crs.srid
+        else:
+            crs = None  # will be resolved
+
+        # Wrap in an element that the filter can use.
+        CRS.tag_geometry(polygon, axis_order=AxisOrder.AUTHORITY)
+        return cls(srs=crs, geos_data=polygon)
+
+    @classmethod
+    def from_xml(cls, element: NSElement):
         """Push the whole <gml:...> element into the GEOS parser.
         This avoids having to support the whole GEOS logic.
 
         GML is a complex beast with many different forms for the same thing:
         http://erouault.blogspot.com/2014/04/gml-madness.html
         """
-        srs = CRS.from_string(get_attribute(element, "srsName"))
+        srs = CRS.from_string(element.get_str_attribute("srsName"))
 
         # Push the whole <gml:...> element into the GEOS parser.
         # This avoids having to support the whole GEOS logic.
         geos_data = GEOSGeometry.from_gml(tostring(element))
         geos_data.srid = srs.srid
+        CRS.tag_geometry(geos_data, axis_order=AxisOrder.AUTHORITY)
         return cls(srs=srs, geos_data=geos_data)
 
     def __repr__(self):
         # Better rendering for unit test debugging
-        return f"GMLGEOSGeometry(srs={self.srs!r}, geos_data=GEOSGeometry({self.geos_data.wkt!r}))"
+        return f"{self.__class__.__name__}(srs={self.srs!r}, geos_data=GEOSGeometry({self.geos_data.wkt!r}))"
 
     @property
     def wkt(self) -> str:
@@ -77,24 +105,57 @@ class GEOSGMLGeometry(AbstractGeometry):
     def json(self):
         return self.geos_data.json
 
-    def build_rhs(self, compiler):
-        return self.geos_data
-
-
-@tag_registry.register("After", GML32)
-@tag_registry.register("Before", GML32)
-@tag_registry.register("Begins", GML32)
-@tag_registry.register("BegunBy", GML32)
-@tag_registry.register("TContains", GML32)
-@tag_registry.register("TEquals", GML32)
-@tag_registry.register("TOverlaps", GML32)
-@tag_registry.register("During", GML32)
-@tag_registry.register("Meets", GML32)
-@tag_registry.register("OverlappedBy", GML32)
-@tag_registry.register("MetBy", GML32)
-@tag_registry.register("EndedBy", GML32)
-@tag_registry.register("AnyInteracts", GML32)
-class TM_GeometricPrimitive(TM_Object):
-    """Not implemented: the whole GML temporal logic"""
-
-    xml_ns = GML32
+    def build_rhs(self, compiler: CompiledQuery):
+        # Perform final validation during the construction of the query.
+        if self.srs is None:
+            # When the feature type is known, apply its default CRS.
+            # This is not possible in XML parsing, but may happen for BBOX parsing.
+            self.srs = compiler.feature_types[0].crs
+            self.geos_data.srid = self.srs.srid  # assign default CRS to geometry
+        elif compiler.feature_types:  # for unit tests
+            self.srs = compiler.feature_types[0].resolve_crs(self.srs, locator="bbox")
+
+        # Make sure the data is suitable for processing by the ORM.
+        # The database needs the geometry in traditional (x/y) ordering.
+        if self.srs.is_north_east_order:
+            return self.srs.apply_to(self.geos_data, clone=True, axis_order=AxisOrder.TRADITIONAL)
+        else:
+            return self.geos_data
+
+
+@tag_registry.register("TimeInstant", hidden=True)
+@tag_registry.register("TimePeriod", hidden=True)
+class AbstractTimeGeometricPrimitive(AbstractTimePrimitive):
+    """Not implemented: the whole GML temporal logic.
+
+    Examples for GML time elements include::
+
+      <gml:TimeInstant gml:id="TI1">
+         <gml:timePosition>2005-05-19T09:28:40Z</gml:timePosition>
+      </gml:TimeInstant>
+
+    and::
+
+      <gml:TimePeriod gml:id="TP1">
+         <gml:begin>
+            <gml:TimeInstant gml:id="TI1">
+               <gml:timePosition>2005-05-17T00:00:00Z</gml:timePosition>
+            </gml:TimeInstant>
+         </gml:begin>
+         <gml:end>
+            <gml:TimeInstant gml:id="TI2">
+               <gml:timePosition>2005-05-23T00:00:00Z</gml:timePosition>
+            </gml:TimeInstant>
+         </gml:end>
+      </gml:TimePeriod>
+    """
+
+    xml_ns = xmlns.gml32
+
+
+@tag_registry.register("TimeNode", hidden=True)
+@tag_registry.register("TimeEdge", hidden=True)
+class AbstractTimeTopologyPrimitiveType(AbstractTimePrimitive):
+    """Not implemented: GML temporal logic for TimeNode/TimeEdge."""
+
+    xml_ns = xmlns.gml32

gisserver/parsers/ows/__init__.py

@@ -0,0 +1,25 @@
+"""Generic Open Web Services (OWS) protocol bits to handle incoming requests.
+
+This is the common logic between WFS, WMS and other protocols.
+
+These translate both request-syntax formats in the same internal objects
+that the rest of the controller/view logic can use.
+"""
+
+from .kvp import KVPRequest
+from .requests import (
+    BaseOwsRequest,
+    parse_get_request,
+    parse_post_request,
+    resolve_kvp_parser_class,
+    resolve_xml_parser_class,
+)
+
+__all__ = (
+    "KVPRequest",
+    "BaseOwsRequest",
+    "resolve_kvp_parser_class",
+    "resolve_xml_parser_class",
+    "parse_get_request",
+    "parse_post_request",
+)