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

gisserver/parsers/fes20/expressions.py

@@ -1,25 +1,45 @@
 """These classes map to the FES 2.0 specification for expressions.
 The class names are identical to those in the FES spec.
+
+Inheritance structure:
+
+* :class:`Expression`
+
+ * :class:`Function` for ``<fes:Function>``.
+ * :class:`Literal` for ``<fes:Literal>``.
+ * :class:`ValueReference` for ``<fes:ValueReference>``.
+ * :class:`BinaryOperator` for FES 1.0 compatibility.
+
+The :class:`BinaryOperator` is included as expression
+to handle FES 1.0 :class:`BinaryOperatorType` arithmetic tags:
+``<fes:Add>``, ``<fes:Sub>``, ``<fes:Mul>``, ``<fes:Div>``.
 """
 
 from __future__ import annotations
 
 import operator
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import date, datetime
 from decimal import Decimal as D
 from functools import cached_property
 from typing import Union
-from xml.etree.ElementTree import Element
 
-from django.contrib.gis.geos import GEOSGeometry
+from django.contrib.gis import geos
+from django.contrib.gis.db import models as gis_models
+from django.core.exceptions import ValidationError
 from django.db import models
-from django.db.models import Func, Q, Value
+from django.db.models import Q, Value
 from django.db.models.expressions import Combinable
 
 from gisserver.exceptions import ExternalParsingError
-from gisserver.parsers.base import BaseNode, TagNameEnum, tag_registry
-from gisserver.parsers.fes20.functions import function_registry
+from gisserver.extensions.functions import function_registry
+from gisserver.parsers.ast import (
+    AstNode,
+    TagNameEnum,
+    expect_no_children,
+    expect_tag,
+    tag_registry,
+)
 from gisserver.parsers.gml import (
     GM_Envelope,
     GM_Object,
@@ -27,12 +47,12 @@ from gisserver.parsers.gml import (
     is_gml_element,
     parse_gml_node,
 )
-from gisserver.parsers.tags import expect_tag, get_attribute
+from gisserver.parsers.query import RhsTypes
 from gisserver.parsers.values import auto_cast
-from gisserver.types import FES20, ORMPath, XsdTypes, split_xml_name
+from gisserver.parsers.xml import NSElement, parse_qname, xmlns
+from gisserver.types import XPathMatch, XsdTypes
 
 NoneType = type(None)
-RhsTypes = Union[Combinable, Func, Q, GEOSGeometry, bool, int, str, date, datetime, tuple]
 ParsedValue = Union[int, str, date, D, datetime, GM_Object, GM_Envelope, TM_Object, NoneType]
 
 OUTPUT_FIELDS = {
@@ -43,6 +63,15 @@ OUTPUT_FIELDS = {
     datetime: models.DateTimeField(),
     float: models.FloatField(),
     D: models.DecimalField(),
+    geos.GEOSGeometry: gis_models.GeometryField(),
+    geos.Point: gis_models.PointField(),
+    geos.LineString: gis_models.LineStringField(),
+    geos.LinearRing: gis_models.LineStringField(),
+    geos.Polygon: gis_models.PolygonField(),
+    geos.MultiPoint: gis_models.MultiPointField(),
+    geos.MultiPolygon: gis_models.MultiPolygonField(),
+    geos.MultiLineString: gis_models.MultiLineStringField(),
+    geos.GeometryCollection: gis_models.GeometryCollectionField(),
 }
 
 
@@ -59,10 +88,20 @@ class BinaryOperatorType(TagNameEnum):
     Div = operator.truediv
 
 
-class Expression(BaseNode):
-    """Abstract base class, as defined by FES spec."""
+class Expression(AstNode):
+    """Abstract base class, as defined by FES spec.
+
+    The FES spec defines the following subclasses:
+
+    * :class:`ValueReference` (pointing to a field name)
+    * :class:`Literal` (a scalar value)
+    * :class:`Function` (a transformation for a value/field)
+
+    When code uses ``Expression.child_from_xml(element)``, the AST logic will
+    initialize the correct subclass for those elements.
+    """
 
-    xml_ns = FES20
+    xml_ns = xmlns.fes20
 
     def build_lhs(self, compiler) -> str:
         """Get the expression as the left-hand-side of the equation.
@@ -86,7 +125,21 @@ class Expression(BaseNode):
 @dataclass(repr=False)
 @tag_registry.register("Literal")
 class Literal(Expression):
-    """The <fes:Literal> element that holds a literal value"""
+    """The ``<fes:Literal>`` element that holds a literal value.
+
+    This can be a string value, possibly annotated with a type::
+
+        <fes:Literal type="xs:boolean">true</fes:Literal>
+
+    Following the spec, the value may also contain a complete geometry::
+
+        <fes:Literal>
+            <gml:Envelope xmlns:gml="http://www.opengis.net/gml/3.2" srsName="urn:ogc:def:crs:EPSG::4326">
+                <gml:lowerCorner>5.7 53.1</gml:lowerCorner>
+                <gml:upperCorner>6.1 53.5</gml:upperCorner>
+            </gml:Envelope>
+        </fes:Literal>
+    """
 
     # The XSD definition even defines a sequence of xsd:any as possible member!
     raw_value: NoneType | str | GM_Object | GM_Envelope | TM_Object
@@ -100,7 +153,9 @@ class Literal(Expression):
 
     @cached_property
     def value(self) -> ParsedValue:  # officially <xsd:any>
-        """Access the value of the element, cast to the appropriate data type."""
+        """Access the value of the element, cast to the appropriate data type.
+        :raises ExternalParsingError: When the value can't be converted to the proper type.
+        """
         if not isinstance(self.raw_value, str):
             return self.raw_value  # GML element or None
         elif self.type:
@@ -112,19 +167,20 @@ class Literal(Expression):
 
     @cached_property
     def type(self) -> XsdTypes | None:
+        """Tell which datatype the literal holds.
+        This returns the type="..." value of the element.
+        """
         if not self.raw_type:
             return None
 
-        xmlns, localname = split_xml_name(self.raw_type)
-        if xmlns == "gml":
-            return XsdTypes(self.raw_type)
-        else:
-            # No idea what XMLSchema was prefixed as (could be ns0 instead of xs:)
-            return XsdTypes(localname)
+        # The raw type is already translated into a fully qualified XML name,
+        # which also allows defining types as "ns0:string", "xs:string" or "xsd:string".
+        # These are directly matched to the XsdTypes enum value.
+        return XsdTypes(self.raw_type)
 
     @classmethod
-    @expect_tag(FES20, "Literal")
-    def from_xml(cls, element: Element):
+    @expect_tag(xmlns.fes20, "Literal")
+    def from_xml(cls, element: NSElement):
         children = len(element)
         if not children:
             # Common case: value is raw text
@@ -137,7 +193,10 @@ class Literal(Expression):
                 f"Unsupported child element for <Literal> element: {element[0].tag}."
             )
 
-        return cls(raw_value=raw_value, raw_type=element.get("type"))
+        return cls(
+            raw_value=raw_value,
+            raw_type=parse_qname(element.attrib.get("type"), element.ns_aliases),
+        )
 
     def build_lhs(self, compiler) -> str:
         """Alias the value when it's used in the left-hand-side.
@@ -166,14 +225,23 @@ class Literal(Expression):
 @tag_registry.register("ValueReference")
 @tag_registry.register("PropertyName", hidden=True)  # FES 1.0 name that old clients still use.
 class ValueReference(Expression):
-    """The <fes:ValueReference> element that holds an XPath string.
+    """The ``<fes:ValueReference>`` element that holds an XPath string.
     In the fes XSD, this is declared as a subclass of xsd:string.
 
+    This parses the syntax like::
+
+        <fes:ValueReference>field-name</fes:ValueReference>
+        <fes:ValueReference>path/to/field-name</fes:ValueReference>
+        <fes:ValueReference>collection[@attr=value]/field-name</fes:ValueReference>
+
     The old WFS1/FES1 "PropertyName" is allowed as an alias.
     Various clients still send this, and mapserver/geoserver support this.
     """
 
+    #: The XPath value
     xpath: str
+    #: The known namespaces aliases at this point in the XML tree
+    xpath_ns_aliases: dict[str, str] | None = field(compare=False, default=None)
 
     def __str__(self):
         return self.xpath
@@ -182,53 +250,56 @@ class ValueReference(Expression):
         return f"ValueReference({self.xpath!r})"
 
     @classmethod
-    @expect_tag(FES20, "ValueReference", "PropertyName", leaf=True)
-    def from_xml(cls, element: Element):
-        return cls(xpath=element.text)
+    @expect_tag(xmlns.fes20, "ValueReference", "PropertyName")
+    @expect_no_children
+    def from_xml(cls, element: NSElement):
+        return cls(xpath=element.text, xpath_ns_aliases=element.ns_aliases)
 
     def build_lhs(self, compiler) -> str:
-        """Optimized LHS: there is no need to alias a field lookup through an annotation."""
-        match = self.parse_xpath(compiler.feature_type)
+        """Use the field name in a left-hand-side expression."""
+        # Optimized from base class: fields don't need an alias lookup through annotations.
+        match = self.parse_xpath(compiler.feature_types)
         return match.build_lhs(compiler)
 
     def build_rhs(self, compiler) -> RhsTypes:
-        """Return the value as F-expression"""
-        match = self.parse_xpath(compiler.feature_type)
+        """Use the field name in a right-hand expression.
+        This generates an F-expression for the ORM."""
+        match = self.parse_xpath(compiler.feature_types)
         return match.build_rhs(compiler)
 
-    def parse_xpath(self, feature_type=None) -> ORMPath:
+    def parse_xpath(self, feature_types: list) -> XPathMatch:
         """Convert the XPath into the required ORM query elements."""
-        if feature_type is not None:
-            # Can resolve against XSD paths, find the correct DB field name
-            return feature_type.resolve_element(self.xpath)
-        else:
-            # Only used by unit testing (when feature_type is not given).
-            parts = [word.strip() for word in self.xpath.split("/")]
-            return ORMPath(orm_path="__".join(parts), orm_filters=None)
-
-    @cached_property
-    def element_name(self):
-        """Tell which element this reference points to."""
-        return self.xpath.rpartition("/")[2]
+        return feature_types[0].resolve_element(self.xpath, self.xpath_ns_aliases)
 
 
 @dataclass
 @tag_registry.register("Function")
 class Function(Expression):
-    """The <fes:Function name="..."> element."""
+    """The ``<fes:Function name="...">`` element.
+
+    This parses the syntax such as::
+
+        <fes:Function name="Add">
+            <fes:ValueReference>field-name</fes:ValueReference>
+            <fes:Literal>2</fes:Literal>
+        </fes:Function>
+
+    Each argument of the function can be another :class:`Expression`,
+    such as a :class:`Function`, :class:`ValueReference` or :class:`Literal`.
+    """
 
     name: str  # scoped name
     arguments: list[Expression]  # xsd:element ref="fes20:expression"
 
     @classmethod
-    @expect_tag(FES20, "Function")
-    def from_xml(cls, element: Element):
+    @expect_tag(xmlns.fes20, "Function")
+    def from_xml(cls, element: NSElement):
         return cls(
-            name=get_attribute(element, "name"),
-            arguments=[Expression.from_child_xml(child) for child in element],
+            name=element.get_str_attribute("name"),
+            arguments=[Expression.child_from_xml(child) for child in element],
         )
 
-    def build_rhs(self, compiler) -> RhsTypes:
+    def build_rhs(self, compiler) -> models.Func:
         """Build the SQL function object"""
         db_function = function_registry.resolve_function(self.name)
         args = [arg.build_rhs(compiler) for arg in self.arguments]
@@ -236,31 +307,74 @@ class Function(Expression):
 
 
 @dataclass
-@tag_registry.register_names(BinaryOperatorType)
+@tag_registry.register(BinaryOperatorType)
 class BinaryOperator(Expression):
     """Support for FES 1.0 arithmetic operators.
 
+    This parses a syntax like::
+
+        <fes:Add>
+            <fes:ValueReference>field-name</fes:ValueReference>
+            <fes:Literal>2</fes:Literal>
+        </fes:Add>
+
+    The operator can be a ``<fes:Add>``, ``<fes:Sub>``, ``<fes:Mul>``, ``<fes:Div>``.
+
     These are no longer part of the FES 2.0 spec, but clients (like QGis)
-    still assume the server supports these. Hence, these need to be included.
+    still assume the server use these. Hence, these need to be included.
     """
 
     _operatorType: BinaryOperatorType
     expression: tuple[Expression, Expression]
 
     @classmethod
-    def from_xml(cls, element: Element):
+    def from_xml(cls, element: NSElement):
         return cls(
             _operatorType=BinaryOperatorType.from_xml(element),
             expression=(
-                Expression.from_child_xml(element[0]),
-                Expression.from_child_xml(element[1]),
+                Expression.child_from_xml(element[0]),
+                Expression.child_from_xml(element[1]),
             ),
         )
 
     def build_rhs(self, compiler) -> RhsTypes:
-        value1 = _make_combinable(self.expression[0].build_rhs(compiler))
-        value2 = _make_combinable(self.expression[1].build_rhs(compiler))
-        return self._operatorType.value(value1, value2)
+        self.validate_arithmetic(compiler, self.expression[0], self.expression[1])
+        value1 = self.expression[0].build_rhs(compiler)
+        value2 = self.expression[1].build_rhs(compiler)
+
+        # Func() + 2 or 2 + Func() are automatically handled,
+        # but Q(..) + 2 or 2 + Q(..) aren't.
+        # When both are values, a direct calculation takes place in Python.
+        if isinstance(value1, Q):
+            value2 = _make_combinable(value2)
+        if isinstance(value2, Q):
+            value1 = _make_combinable(value1)
+
+        try:
+            # This calls somthing like: operator.add(F("field"), 2) or operator.add(1, 2)
+            return self._operatorType.value(value1, value2)
+        except (TypeError, ValueError, ArithmeticError) as e:
+            raise ValidationError(
+                f"Invalid data for the 'fes:{self._operatorType.name}' element: {value1} {value2}"
+            ) from e
+
+    def validate_arithmetic(self, compiler, lhs: Expression, rhs: Expression):
+        """Check whether values support arithmetic operators."""
+        if isinstance(lhs, Literal) and isinstance(rhs, ValueReference):
+            lhs, rhs = rhs, lhs
+
+        if isinstance(lhs, ValueReference):
+            xsd_element = lhs.parse_xpath(compiler.feature_types).child
+            if isinstance(rhs, Literal):
+                # Since the element is resolved, inform the Literal how to parse the value.
+                # This avoids various validation errors along the path.
+                rhs.bind_type(xsd_element.type)
+
+                # Validate the expressions against each other
+                # This raises an ValidationError when values can't be converted
+                xsd_element.to_python(rhs.raw_value)
+
+        return None
 
 
 def _make_combinable(value) -> Combinable | Q:

gisserver/parsers/fes20/filters.py

@@ -1,38 +1,115 @@
 from __future__ import annotations
 
-from typing import AnyStr, Union
-from xml.etree.ElementTree import Element, QName
+from dataclasses import dataclass, field
+from typing import AnyStr, ClassVar, Union
 
-from defusedxml.ElementTree import ParseError, fromstring
+from django.db.models import Q
 
-from gisserver.exceptions import ExternalParsingError
-from gisserver.parsers.base import tag_registry
-from gisserver.parsers.tags import expect_tag
-from gisserver.types import FES20, GML32
+from gisserver.exceptions import InvalidParameterValue
+from gisserver.parsers.ast import AstNode, expect_tag, tag_registry
+from gisserver.parsers.gml import GEOSGMLGeometry
+from gisserver.parsers.ows import KVPRequest
+from gisserver.parsers.query import CompiledQuery
+from gisserver.parsers.xml import NSElement, parse_xml_from_string, xmlns
 
-from . import expressions, identifiers, operators, query
+from . import expressions, identifiers, operators
 
+#: The FES element group that can be used as body for the :class:`Filter` element.
 FilterPredicates = Union[expressions.Function, operators.Operator]
 
+# Fully qualified tag names
+FES_RESOURCE_ID = xmlns.fes20.qname("ResourceId")
 
-class Filter:
-    """The <fes:Filter> element.
 
-    As this is a wrapper, it only contains a "predicate" element with the contents.
+@dataclass
+@tag_registry.register("Filter", xmlns.fes20)
+class Filter(AstNode):
+    """The ``<fes:Filter>`` element.
+
+    This parses and handles the syntax::
+
+        <fes:Filter>
+            <fes:SomeOperator>
+                ...
+            </fes:SomeOperator>
+        </fes:Filter>
+
+    The :meth:`build_query` will convert the parsed tree
+    into a format that can build a Django ORM QuerySet.
+
+    .. seealso:: https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/filter_xsd.html#Filter
     """
 
-    query_language = "urn:ogc:def:queryLanguage:OGC-FES:Filter"
+    query_language: ClassVar[str] = "urn:ogc:def:queryLanguage:OGC-FES:Filter"
 
+    #: The filter predicate (body)
     predicate: FilterPredicates
-    source: AnyStr | None
 
-    def __init__(self, predicate: FilterPredicates, source: AnyStr | None = None):
-        self.predicate = predicate
-        self.source = source
+    source: AnyStr | None = field(default=None, compare=False)
 
     @classmethod
-    def from_string(cls, text: AnyStr) -> Filter:
-        """Parse an XML <fes20:Filter> string.
+    def from_kvp_request(cls, kvp: KVPRequest) -> Filter | None:
+        """Parse the filter from the GET request."""
+
+        # Check filter language
+        filter_language = kvp.get_str("FILTER_LANGUAGE", default=cls.query_language)
+        if filter_language != cls.query_language:
+            raise InvalidParameterValue(
+                f"Invalid value for filterLanguage: {filter_language}", locator="filterLanguage"
+            )
+
+        # Parse filter
+        filter = kvp.get_custom(
+            "filter", default=None, parser=lambda x: cls.from_string(x, kvp.ns_aliases)
+        )
+
+        # Parse alternatives to filter
+        resource_ids = [
+            identifiers.ResourceId.from_string(rid, kvp.ns_aliases)
+            for rid in kvp.get_list("resourceID", default=[])
+        ]
+        bbox = kvp.get_custom("bbox", default=None, parser=GEOSGMLGeometry.from_bbox)
+
+        # Make sure the various query options are not mixed.
+        cls.validate_kvp_exclusions(filter, bbox, resource_ids)
+
+        if filter is None:
+            # See if the other KVP parameters still provide a basic filter.
+            # Instead of implementing these parameters separately in the AdhocQueryExpression,
+            # they are implemented by constructing the filter AST internally.
+            if resource_ids:
+                filter = Filter(predicate=operators.IdOperator(resource_ids))
+            elif bbox is not None:
+                filter = Filter(
+                    predicate=operators.BinarySpatialOperator(
+                        operatorType=operators.SpatialOperatorName.BBOX,
+                        operand1=None,
+                        operand2=bbox,
+                    )
+                )
+
+        return filter
+
+    @classmethod
+    def validate_kvp_exclusions(
+        cls, filter: Filter | None, bbox: GEOSGMLGeometry | None, resource_ids: list
+    ):
+        """Validate mutually exclusive parameters"""
+        if filter is not None and (bbox is not None or resource_ids):
+            raise InvalidParameterValue(
+                "The FILTER parameter is mutually exclusive with BBOX and RESOURCEID",
+                locator="filter",
+            )
+
+        if resource_ids and (bbox is not None or filter is not None):
+            raise InvalidParameterValue(
+                "The RESOURCEID parameter is mutually exclusive with BBOX and FILTER",
+                locator="resourceId",
+            )
+
+    @classmethod
+    def from_string(cls, text: AnyStr, ns_aliases: dict[str, str] | None = None) -> Filter:
+        """Parse an XML ``<fes:Filter>`` string.
 
         This uses defusedxml by default, to avoid various XML injection attacks.
 
@@ -47,51 +124,45 @@ class Filter:
             if "xmlns" not in first_tag and (
                 first_tag == "<Filter" or first_tag.startswith("<Filter ")
             ):
-                text = f'{first_tag} xmlns="{FES20}" xmlns:gml="{GML32}"{text[end_first:]}'
+                text = f'{first_tag} xmlns="{xmlns.fes20}" xmlns:gml="{xmlns.gml32}"{text[end_first:]}'
 
-        try:
-            root_element = fromstring(text)
-        except ParseError as e:
-            # Offer consistent results for callers to check for invalid data.
-            raise ExternalParsingError(str(e)) from e
+        root_element = parse_xml_from_string(text, extra_ns_aliases=ns_aliases)
         return Filter.from_xml(root_element, source=text)
 
     @classmethod
-    @expect_tag(FES20, "Filter")
-    def from_xml(cls, element: Element, source: AnyStr | None = None) -> Filter:
+    @expect_tag(xmlns.fes20, "Filter")
+    def from_xml(cls, element: NSElement, source: AnyStr | None = None) -> Filter:
         """Parse the <fes20:Filter> element."""
-        if len(element) > 1 or element[0].tag == QName(FES20, "ResourceId"):
+        if len(element) > 1 or element[0].tag == FES_RESOURCE_ID:
             # fes20:ResourceId is the only element that may appear multiple times.
+            # Wrap it in an IdOperator so this class can have a single element as predicate.
             return Filter(
                 predicate=operators.IdOperator(
-                    [identifiers.Id.from_child_xml(child) for child in element]
+                    [identifiers.Id.child_from_xml(child) for child in element]
                 ),
                 source=source,
             )
         else:
             return Filter(
-                predicate=tag_registry.from_child_xml(
-                    element[0], allowed_types=(expressions.Function, operators.Operator)
+                # Can be Function or Operator (e.g. BinaryComparisonOperator),
+                # but not Literal or ValueReference.
+                predicate=tag_registry.node_from_xml(
+                    element[0], allowed_types=FilterPredicates.__args__
                 ),
                 source=source,
             )
 
-    def compile_query(self, feature_type=None, using=None) -> query.CompiledQuery:
+    def build_query(self, compiler: CompiledQuery) -> Q | None:
         """Collect the data to perform a Django ORM query."""
-        compiler = query.CompiledQuery(feature_type=feature_type, using=using)
-
         # Function, Operator, IdList
-        q_object = self.predicate.build_query(compiler)
-        if q_object is not None:
-            compiler.add_lookups(q_object)
-
-        return compiler
+        # The operators may add the logic themselves, or return a Q object.
+        return self.predicate.build_query(compiler)
 
-    def __repr__(self):
-        return f"Filter(predicate={self.predicate!r}, source={self.source})"
-
-    def __eq__(self, other):
-        if isinstance(other, Filter):
-            return self.predicate == other.predicate
+    def get_resource_id_types(self) -> list[str] | None:
+        """When the filter predicate consists of ``<fes:ResourceId>`` elements, return those.
+        This can return an empty list in case a ``<fes:ResourceId>`` object doesn't define a type.
+        """
+        if isinstance(self.predicate, operators.IdOperator):
+            return self.predicate.get_type_names()
         else:
-            return NotImplemented
+            return None