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

gisserver/parsers/fes20/sorting.py

@@ -4,7 +4,13 @@ from dataclasses import dataclass
 from enum import Enum
 
 from gisserver.exceptions import InvalidParameterValue
+from gisserver.parsers.ast import BaseNode, 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):
@@ -24,52 +30,117 @@ 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(BaseNode):
+    """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, "SortOrder")
+    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(BaseNode):
+    """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.
+    """
 
     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)
+    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

@@ -5,45 +5,46 @@ These functions locate GML objects, and redirect to the proper parser.
 
 from __future__ import annotations
 
-from xml.etree.ElementTree import Element
-
-from defusedxml.ElementTree import fromstring
+from typing import Union
 
 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
+from .geometries import GEOSGMLGeometry, is_gml_element  # also do tag registration
 
 # All known root nodes as GML object:
-FES_GML_NODES = (GM_Object, GM_Envelope, TM_Object)
+GmlRootNodes = Union[GM_Object, GM_Envelope, TM_Object]
 
 __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) -> GmlRootNodes:
     """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:
+def parse_gml_node(element: NSElement) -> GmlRootNodes:
     """Parse the 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=GmlRootNodes.__args__)
 
 
-def find_gml_nodes(element: Element) -> list[Element]:
+def find_gml_nodes(element: NSElement) -> list[NSElement]:
     """Find all gml elements in a node"""
     result = []
     for child in element:

gisserver/parsers/gml/base.py

@@ -4,7 +4,10 @@ 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 BaseNode
+from gisserver.parsers.query import CompiledQuery
 
 
 class AbstractGeometry(BaseNode):
@@ -13,7 +16,7 @@ class AbstractGeometry(BaseNode):
     <gml:AbstractGeometry> implements the ISO 19107 GM_Object.
     """
 
-    def build_rhs(self, compiler):
+    def build_rhs(self, compiler: CompiledQuery):
         # Allow the value to be used in a binary operator
         raise NotImplementedError()
 

gisserver/parsers/gml/geometries.py

@@ -4,14 +4,15 @@ 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.geos import GEOSGeometry, Polygon
 
+from gisserver.exceptions import ExternalParsingError
 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.parsers.ast import tag_registry
+from gisserver.parsers.query import CompiledQuery
+from gisserver.parsers.xml import NSElement, xmlns
 
 from .base import AbstractGeometry, TM_Object
 
@@ -24,18 +25,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,20 +46,42 @@ 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.
+        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.
@@ -77,24 +102,33 @@ class GEOSGMLGeometry(AbstractGeometry):
     def json(self):
         return self.geos_data.json
 
-    def build_rhs(self, compiler):
+    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")
+
         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)
+@tag_registry.register("After")
+@tag_registry.register("Before")
+@tag_registry.register("Begins")
+@tag_registry.register("BegunBy")
+@tag_registry.register("TContains")
+@tag_registry.register("TEquals")
+@tag_registry.register("TOverlaps")
+@tag_registry.register("During")
+@tag_registry.register("Meets")
+@tag_registry.register("OverlappedBy")
+@tag_registry.register("MetBy")
+@tag_registry.register("EndedBy")
+@tag_registry.register("AnyInteracts")
 class TM_GeometricPrimitive(TM_Object):
     """Not implemented: the whole GML temporal logic"""
 
-    xml_ns = GML32
+    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",
+)

gisserver/parsers/ows/kvp.py

@@ -0,0 +1,190 @@
+"""Parsing the Key-Value-Pair (KVP) request format."""
+
+from __future__ import annotations
+
+from copy import copy
+
+from gisserver.exceptions import (
+    InvalidParameterValue,
+    MissingParameterValue,
+    OperationParsingFailed,
+    wrap_parser_errors,
+)
+from gisserver.parsers.xml import parse_qname, xmlns
+
+REQUIRED = ...  # sentinel value
+
+
+class KVPRequest:
+    """The Key-Value-Pair (KVP) request format.
+
+    This handles parameters from the HTTP GET request.
+    It includes notation format support for certain parameters,
+    such as comma-separated lists, and parenthesis-grouping notations.
+
+    Some basic validation is performed, allowing to convert the data into Python types.
+    """
+
+    def __init__(self, query_string: dict[str, str], ns_aliases: dict[str, str] | None = None):
+        # The parameters are case-insensitive.
+        self.params = {name.upper(): value for name, value in query_string.items()}
+
+        # Make sure most common namespaces are known for resolving them.
+        self.ns_aliases = {
+            **xmlns.as_ns_aliases(),  # some defaults in case these are missing in the request
+            **(ns_aliases or {}),  # our local application namespaces
+            **parse_kvp_namespaces(self.params.get("NAMESPACES")),  # extra in the request
+        }
+
+    def __contains__(self, name: str) -> bool:
+        """Tell whether a parameter is present."""
+        return name.upper() in self.params
+
+    def get_custom(self, name: str, *, alias: str | None = None, default=REQUIRED, parser=None):
+        """Retrieve a value by name.
+        This performs basic validation, similar to what the XML parsing does.
+
+        Any parsing errors or validation checks are raised as WFS Exceptions,
+        meaning the client will get the appropriate response.
+
+        :param name: The name of the parameter, typically given in its XML notation format (camelCase).
+        :param alias: An older WFS 1 to try for compatibility (e.g. TYPENAMES/TYPENAME, COUNT/MAXFEATURES)
+        :param default: The default value to return. If not provided, the parameter is required.
+        :param parser: A custom Python function or type to convert the value with.
+        """
+        kvp_name = name.upper()
+        value = self.params.get(kvp_name)
+        if not value and alias:
+            value = self.params.get(alias.upper())
+
+        # Check required field settings, both empty and missing value are treated the same.
+        if not value:
+            if default is REQUIRED:
+                if value is None:
+                    raise MissingParameterValue(
+                        f"Missing required '{name}' parameter.", locator=name
+                    )
+                else:
+                    raise InvalidParameterValue(f"Empty '{kvp_name}' parameter", locator=name)
+            return default
+
+        # Allow conversion into a python object
+        if parser is not None:
+            with wrap_parser_errors(kvp_name, locator=name):
+                return parser(value)
+        else:
+            return value
+
+    def get_str(
+        self, name: str, *, alias: str | None = None, default: str | None = REQUIRED
+    ) -> str | None:
+        """Retrieve a string value from the request."""
+        return self.get_custom(name, alias=alias, default=default)
+
+    def get_int(
+        self, name: str, *, alias: str | None = None, default: int | None = REQUIRED
+    ) -> int | None:
+        """Retrieve an integer value from the request."""
+        return self.get_custom(name, alias=alias, default=default, parser=int)
+
+    def get_list(
+        self, name, *, alias: str | None = None, default: list | None = REQUIRED
+    ) -> list[str] | None:
+        """Retrieve a comma-separated list value from the request."""
+        return self.get_custom(
+            name,
+            alias=alias,
+            default=default,
+            parser=lambda x: x.split(","),
+        )
+
+    def parse_qname(self, value) -> str:
+        """Convert the value to an XML fully qualified name."""
+        return parse_qname(value, self.ns_aliases)
+
+    def split_parameter_lists(self) -> list[KVPRequest]:
+        """Split the parameter lists into individual requests.
+
+        This translates a request such as::
+
+            TYPENAMES=(ns1:F1,ns2:F2)(ns1:F1,ns1:F1)
+            &ALIASES=(A,B)(C,D)
+            &FILTER=(<Filter>… for A,B …</Filter>)(<Filter>…for C,D…</Filter>)
+
+        into separate pairs:
+
+            TYPENAMES=ns1:F1,ns2:F2&ALIASES=A,B&FILTER=<Filter>…for A,B…</Filter>
+            TYPENAMES=ns1:F1,ns1:F1&ALIASES=C,D&FILTER=<Filter>…for C,D…</Filter>
+
+        It's both possible have some query parameters split and some shared.
+        For example to have two different bounding boxes:
+
+             TYPENAMES=(INWATER_1M)(BuiltUpA_1M)&BBOX=(40.9821,...)(40.5874,...)
+
+        or have a single bounding box for both queries::
+
+             TYPENAMES=(INWATER_1M)(BuiltUpA_1M)&BBOX=40.9821,23.4948,41.0257,23.5525
+        """
+        pairs = {
+            name: value[1:-1].split(")(")
+            for name, value in self.params.items()
+            if value.startswith("(") and value.endswith(")")
+        }
+        if not pairs:
+            return [self]
+
+        pair_sizes = {len(value) for value in pairs.values()}
+        if len(pair_sizes) > 1:
+            keys = sorted(pairs)
+            raise OperationParsingFailed(
+                f"Inconsistent pairs between: {', '.join(keys)}", locator=keys[0]
+            )
+
+        # Produce variations of the same request object
+        pair_size = next(iter(pair_sizes))
+        variants = []
+        for i in range(pair_size):
+            updates = {key: value[i] for key, value in pairs.items()}
+            variant = copy(self)
+            variant.params = {**self.params, **updates}
+            variants.append(variant)
+        return variants
+
+
+def parse_kvp_namespaces(value) -> dict[str, str]:
+    """Parse the 'NAMESPACES' parameter format to lookups.
+
+    The NAMESPACES parameter defines which namespaces are used in the KVP request.
+    When this parameter is not given, the default namespaces are assumed.
+    """
+    if not value:
+        return {}
+
+    # example single value: xmlns(http://example.org)
+    # or: NAMESPACES=xmlns(xml,http://www.w3.org/...),xmlns(wfs,http://www.opengis.net/...)
+    tokens = value.split(",")
+
+    namespaces = {}
+    tokens = iter(tokens)
+    for prefix in tokens:
+        if not prefix.startswith("xmlns("):
+            raise InvalidParameterValue(
+                f"Expected xmlns(...) format: {value}", locator="namespaces"
+            )
+        if prefix.endswith(")"):
+            # xmlns(http://...)
+            uri = prefix[6:-1]
+            prefix = ""
+        else:
+            uri = next(tokens, "")
+            if not uri.endswith(")"):
+                raise InvalidParameterValue(
+                    f"Expected xmlns(prefix,uri) format: {value}",
+                    locator="namespaces",
+                )
+            prefix = prefix[6:]
+            uri = uri[:-1]
+
+        namespaces[prefix] = uri
+
+    return namespaces