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

gisserver/parsers/fes20/operators.py

@@ -1,5 +1,33 @@
 """These classes map to the FES 2.0 specification for operators.
 The class names and attributes are identical to those in the FES spec.
+
+Inheritance structure:
+
+* :class:`Operator`
+
+ * :class:`IdOperator` chains ``<fes:ResourceId>``.
+ * :class:`NonIdOperator`
+
+  * :class:`ComparisonOperator`
+
+   * :class:`BinaryComparisonOperator` for :class:`BinaryComparisonName` tags like ``<fes:PropertyIsEqualTo>``.
+   * :class:`BetweenComparisonOperator` for ``<fes:PropertyIsBetween>``
+   * :class:`LikeOperator` for ``<fes:PropertyIsLike>``.
+   * :class:`NilOperator` for ``<fes:PropertyIsNil>``.
+   * :class:`NullOperator` for ``<fes:PropertyIsNill>``.
+
+  * :class:`SpatialOperator`
+
+   * :class:`DistanceOperator` for the :class:`DistanceOperator` tags: ``<fes:DWithin>`` and ``<fes:Beyond>``.
+   * :class:`BinarySpatialOperator` for :class:`SpatialOperatorName` tags like ``<fes:BBOX>``.
+
+  * :class:`TemporalOperator` for :class:`TemporalOperatorName` tags like ``<fes:After>``.
+  * :class:`LogicalOperator`
+
+   * :class:`BinaryLogicOperator` for the :class:`BinaryLogicType` tags: ``<fes:And>`` and ``<fes:Or>``.
+   * :class:`UnaryLogicOperator` for the :class:`UnaryLogicType` tag: ``<fes:Not>``.
+
+  * :class:`ExtensionOperator` for custom additions.
 """
 
 from __future__ import annotations
@@ -11,7 +39,7 @@ from decimal import Decimal
 from enum import Enum
 from functools import cached_property, reduce
 from itertools import groupby
-from typing import ClassVar, Protocol, Union
+from typing import ClassVar, Union
 
 from django.contrib.gis import measure
 from django.db.models import Q
@@ -23,13 +51,13 @@ from gisserver.exceptions import (
 )
 from gisserver.parsers import gml
 from gisserver.parsers.ast import (
-    BaseNode,
+    AstNode,
     TagNameEnum,
     expect_children,
     expect_tag,
     tag_registry,
 )
-from gisserver.parsers.query import CompiledQuery, RhsTypes
+from gisserver.parsers.query import CompiledQuery, RhsTypes, ScalarTypes
 from gisserver.parsers.values import fix_type_name
 from gisserver.parsers.xml import NSElement, xmlns
 from gisserver.types import GeometryXsdElement, XPathMatch
@@ -40,7 +68,10 @@ from .lookups import ARRAY_LOOKUPS  # also registers the lookups.
 
 logger = logging.getLogger(__name__)
 
+#: Define the types that a ``<gml:SpatialDescription>`` can be:
 SpatialDescription = Union[gml.GM_Object, gml.GM_Envelope, ValueReference]
+
+#: Define the types that a ``<gml:TemporalOperand>`` can be:
 TemporalOperand = Union[gml.TM_Object, ValueReference]
 
 # Fully qualified tag names
@@ -48,16 +79,11 @@ FES_VALUE_REFERENCE = xmlns.fes20.qname("ValueReference")
 FES_DISTANCE = xmlns.fes20.qname("Distance")
 FES_LOWER_BOUNDARY = xmlns.fes20.qname("LowerBoundary")
 FES_UPPER_BOUNDARY = xmlns.fes20.qname("UpperBoundary")
-
-
-class HasBuildRhs(Protocol):
-    """Define interface for any class that has ``build_rhs()``."""
-
-    def build_rhs(self, compiler) -> RhsTypes: ...
+FES1_PROPERTY_NAME = xmlns.fes20.qname("PropertyName")  # old tag sometimes used by clients
 
 
 class MatchAction(Enum):
-    """Values for the 'matchAction' attribute of the BinaryComparisonOperator."""
+    """Values for the 'matchAction' attribute of the :class:`BinaryComparisonOperator`."""
 
     All = "All"
     Any = "Any"
@@ -81,6 +107,14 @@ class BinaryComparisonName(TagNameEnum):
     PropertyIsGreaterThanOrEqualTo = "gte"
 
 
+REVERSE_LOOKUPS = {
+    "gt": "lt",
+    "gte": "lte",
+    "lt": "gt",
+    "lte": "gte",
+}
+
+
 class DistanceOperatorName(TagNameEnum):
     """XML tag names mapped to distance operators for the ORM."""
 
@@ -146,7 +180,8 @@ class UnaryLogicType(TagNameEnum):
 
 
 @dataclass
-class Measure(BaseNode):
+@tag_registry.register("Distance")
+class Measure(AstNode):
     """A measurement for a distance element.
 
     This parses and handles the syntax::
@@ -175,7 +210,7 @@ class Measure(BaseNode):
         return measure.Distance(default_unit=self.uom, **{self.uom: self.value})
 
 
-class Operator(BaseNode):
+class Operator(AstNode):
     """Abstract base class, as defined by FES spec.
 
     This base class is also used in parsing; for example the ``<fes:Filter>``
@@ -192,7 +227,16 @@ class Operator(BaseNode):
 
 @dataclass
 class IdOperator(Operator):
-    """List of ResourceId objects"""
+    """List of :class:`~gisserver.parsers.fes20.identifers.ResourceId`` objects.
+
+    A ``<fes:Filter>`` only has a single predicate.
+    Hence, this operator is used to wrap the ``<fes:ResourceId>`` elements in the syntax::
+
+        <fes:Filter>
+            <fes:ResourceId rid="typename.123" />
+            <fes:ResourceId rid="typename.345" />
+        </fes:Filter>
+    """
 
     id: list[Id]
 
@@ -242,7 +286,7 @@ class NonIdOperator(Operator):
     """Abstract base class, as defined by FES spec.
 
     This is used for nearly all operators,
-    except those that have <fes:ResourceId> elements as children.
+    except those that have ``<fes:ResourceId>`` elements as children.
 
     Some operators, such as the ``<fes:And>``, ``<fes:Or>`` and ``<fes:Not>`` operators
     explicitly support only ``NonIdOperator`` elements as arguments.
@@ -266,18 +310,28 @@ class NonIdOperator(Operator):
         # lhs and rhs are allowed to be reversed. However, the SQL compiler
         # works much simpler when Django can predict the actual data type.
         if isinstance(lhs, Literal) and isinstance(rhs, ValueReference):
+            logger.debug("Filter switches lhs/rhs for %s %s %s", lhs.raw_value, lookup, rhs.xpath)
             lhs, rhs = rhs, lhs
+            lookup = REVERSE_LOOKUPS.get(lookup, lookup)  # >= should become <=
 
-        if compiler.feature_types:
-            lookup = self.validate_comparison(compiler, lhs, lookup, rhs)
+        lookup = self.validate_comparison(compiler, lhs, lookup, rhs)
 
         # Build Django Q-object
-        lhs = lhs.build_lhs(compiler)
+        lhs_orm_name = lhs.build_lhs(compiler)
 
         if isinstance(rhs, (Expression, gml.GM_Object)):
             rhs = rhs.build_rhs(compiler)
-
-        comparison = Q(**{f"{lhs}__{lookup}": rhs})
+            if (
+                isinstance(lhs, ValueReference)
+                and isinstance(rhs, ScalarTypes)
+                and lookup != "isnull"
+            ):
+                # Building the expression resolved as a scalar after all (for BinaryOperator).
+                # It allows performing a better type check:
+                xsd_element = lhs.parse_xpath(compiler.feature_types).child
+                xsd_element.to_python(rhs)
+
+        comparison = Q(**{f"{lhs_orm_name}__{lookup}": rhs})
         return compiler.apply_extra_lookups(comparison)
 
     def validate_comparison(
@@ -286,20 +340,20 @@ class NonIdOperator(Operator):
         lhs: Expression,
         lookup: str,
         rhs: Expression | gml.GM_Object | RhsTypes,
-    ):
+    ) -> str:
         """Validate whether a given comparison is even possible.
 
         For example, comparisons like ``name == "test"`` are fine,
-        but ``geometry < 4`` or ``datefield == 35.2" raise an error.
-
-        The lhs/rhs are expected to be ordered in a logical sequence.
-        So ``<value> == <element>`` should be provided as ``<element> == <value>``.
+        but ``geometry < 4`` or ``datefield == 35.2`` raise an error.
 
         :param compiler: The object that holds the intermediate state
         :param lhs: The left-hand-side of the comparison (e.g. the element).
         :param lookup: The ORM lookup expression being used (e.g. ``equals`` or ``fes_like``).
         :param rhs: The right-hand-side of the comparison (e.g. the value).
         """
+        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
             tag = self._source if self._source is not None else None
@@ -336,6 +390,9 @@ class NonIdOperator(Operator):
                 # When a common case of value comparison is done, the inputs
                 # can be validated before the ORM query is constructed.
                 xsd_element.validate_comparison(rhs.raw_value, lookup=lookup, tag=tag)
+            elif isinstance(rhs, ScalarTypes) and lookup != "isnull":
+                # Can still compare two elements, e.g. date >= ((2020 - 12) - 10) by QGis
+                xsd_element.validate_comparison(rhs, lookup=lookup, tag=tag)
 
         return lookup
 
@@ -347,9 +404,8 @@ class NonIdOperator(Operator):
         rhs: tuple[Expression | ValueReference | gml.GM_Object, Expression | Measure],
     ) -> Q:
         """Use the value in comparison with 2 other values (e.g. between query)"""
-        if compiler.feature_types:
-            self.validate_comparison(compiler, lhs, lookup, rhs[0])
-            self.validate_comparison(compiler, lhs, lookup, rhs[1])
+        self.validate_comparison(compiler, lhs, lookup, rhs[0])
+        self.validate_comparison(compiler, lhs, lookup, rhs[1])
 
         field_name = lhs.build_lhs(compiler)
         comparison = Q(
@@ -390,7 +446,7 @@ class DistanceOperator(SpatialOperator):
     operatorType: DistanceOperatorName
     geometry: gml.GM_Object
     distance: Measure
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     @classmethod
     @expect_children(3, ValueReference, gml.GM_Object, Measure)
@@ -442,7 +498,7 @@ class BinarySpatialOperator(SpatialOperator):
     operatorType: SpatialOperatorName
     operand1: ValueReference | None
     operand2: SpatialDescription
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     @classmethod
     def from_xml(cls, element: NSElement):
@@ -498,7 +554,7 @@ class _ResolvedValueReference(ValueReference):
 
 
 @dataclass
-@tag_registry.register(TemporalOperatorName)  # <After>, <Before>, ...
+@tag_registry.register(TemporalOperatorName, hidden=True)  # <After>, <Before>, ...
 class TemporalOperator(NonIdOperator):
     """Comparisons with dates.
 
@@ -536,7 +592,7 @@ class TemporalOperator(NonIdOperator):
     operatorType: TemporalOperatorName
     operand1: ValueReference
     operand2: TemporalOperand
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     @classmethod
     @expect_children(2, ValueReference, *TemporalOperand.__args__)
@@ -557,15 +613,11 @@ class ComparisonOperator(NonIdOperator):
     and allows grouping various comparisons together.
     """
 
-    # Start counting fresh here, to collect the capabilities
-    # that are listed in the <fes20:ComparisonOperators> node:
-    xml_tags = []
-
 
 @dataclass
 @tag_registry.register(BinaryComparisonName)  # <PropertyIs...>
 class BinaryComparisonOperator(ComparisonOperator):
-    """A comparison between 2 values, e.g. A == B.
+    """A comparison between 2 values, e.g. *A == B*.
 
     This parses and handles the syntax::
 
@@ -588,7 +640,7 @@ class BinaryComparisonOperator(ComparisonOperator):
     _source: str | None = field(compare=False, default=None)
 
     @classmethod
-    @expect_children(2, Expression, Expression)
+    @expect_children(2, Expression, silent_allowed=(FES1_PROPERTY_NAME,))
     def from_xml(cls, element: NSElement):
         return cls(
             operatorType=BinaryComparisonName.from_xml(element),
@@ -626,10 +678,10 @@ class BetweenComparisonOperator(ComparisonOperator):
     expression: Expression
     lowerBoundary: Expression
     upperBoundary: Expression
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     @classmethod
-    @expect_children(3, Expression, "LowerBoundary", "UpperBoundary")
+    @expect_children(3, Expression, FES_LOWER_BOUNDARY, FES_UPPER_BOUNDARY)
     def from_xml(cls, element: NSElement):
         if (element[1].tag != FES_LOWER_BOUNDARY) or (element[2].tag != FES_UPPER_BOUNDARY):
             raise ExternalParsingError(
@@ -678,10 +730,10 @@ class LikeOperator(ComparisonOperator):
     wildCard: str
     singleChar: str
     escapeChar: str
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     @classmethod
-    @expect_children(2, Expression, Expression)
+    @expect_children(2, Expression)
     def from_xml(cls, element: NSElement):
         return cls(
             expression=(
@@ -711,7 +763,7 @@ class LikeOperator(ComparisonOperator):
             rhs = Literal(raw_value=value)
         else:
             raise ExternalParsingError(
-                f"Expected a literal value for the {self.xml_tags[0]} operator."
+                f"Expected a literal value for the {self.xml_name} operator."
             )
 
         # Use the FesLike lookup
@@ -722,7 +774,7 @@ class LikeOperator(ComparisonOperator):
 @tag_registry.register("PropertyIsNil")
 class NilOperator(ComparisonOperator):
     """Check whether the value evaluates to null/None.
-    If the WFS returned a property element with <tns:p xsi:nil='true'>, this returns true.
+    If the WFS returned a property element with ``<app:field xsi:nil='true'>``, this returns true.
 
     It parses and handles syntax such as::
 
@@ -736,7 +788,7 @@ class NilOperator(ComparisonOperator):
 
     expression: Expression | None
     nilReason: str
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     # Allow checking whether the geometry is null
     allow_geometries: ClassVar[bool] = True
@@ -759,7 +811,7 @@ class NilOperator(ComparisonOperator):
 @tag_registry.register("PropertyIsNull")
 class NullOperator(ComparisonOperator):
     """Check whether the property exists.
-    If the WFS would not return the property element <tns:p>, this returns true.
+    If the WFS would not return the property element ``<app:field>``, this returns true.
 
     It parses and handles syntax such as::
 
@@ -771,7 +823,7 @@ class NullOperator(ComparisonOperator):
     """
 
     expression: Expression
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     # Allow checking whether the geometry is null
     allow_geometries: ClassVar[bool] = True
@@ -815,10 +867,10 @@ class BinaryLogicOperator(LogicalOperator):
 
     operands: list[NonIdOperator]
     operatorType: BinaryLogicType
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     @classmethod
-    @expect_children(2, NonIdOperator, NonIdOperator)
+    @expect_children(2, NonIdOperator)
     def from_xml(cls, element: NSElement):
         return cls(
             operands=[NonIdOperator.child_from_xml(child) for child in element],
@@ -848,7 +900,7 @@ class UnaryLogicOperator(LogicalOperator):
 
     operands: NonIdOperator
     operatorType: UnaryLogicType
-    _source: str | None = field(compare=False, default=None)
+    _source: str | None = field(compare=False, default=None, repr=False)
 
     @classmethod
     @expect_children(1, NonIdOperator)

gisserver/parsers/fes20/sorting.py

@@ -1,10 +1,12 @@
+"""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 BaseNode, expect_children, expect_tag, tag_registry
+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
@@ -14,11 +16,16 @@ 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
@@ -38,7 +45,7 @@ class SortOrder(Enum):
 
 @dataclass
 @tag_registry.register("SortProperty", xmlns.fes20)
-class SortProperty(BaseNode):
+class SortProperty(AstNode):
     """This class name is based on the WFS spec.
 
     This parses and handles the syntax::
@@ -60,7 +67,7 @@ class SortProperty(BaseNode):
 
     @classmethod
     @expect_tag(xmlns.fes20, "SortProperty")
-    @expect_children(1, ValueReference, "SortOrder")
+    @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)
@@ -90,7 +97,7 @@ class SortProperty(BaseNode):
 
 @dataclass
 @tag_registry.register("SortBy", xmlns.fes20)
-class SortBy(BaseNode):
+class SortBy(AstNode):
     """The sortBy clause.
 
     This parses and handles the syntax::
@@ -105,10 +112,11 @@ class SortBy(BaseNode):
     It also supports the SORTBY parameter for GET requests.
     """
 
+    #: The ``<fes:SortProperty>`` elements.
     sort_properties: list[SortProperty]
 
     @classmethod
-    @expect_children(1)
+    @expect_children(1, SortProperty)
     def from_xml(cls, element: NSElement) -> SortBy:
         """Parse the XML tag."""
         return cls(

gisserver/parsers/gml/__init__.py

@@ -1,12 +1,10 @@
-"""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 typing import Union
-
 from gisserver.exceptions import ExternalParsingError
 from gisserver.parsers.ast import tag_registry
 from gisserver.parsers.xml import NSElement, parse_xml_from_string
@@ -14,9 +12,6 @@ from gisserver.parsers.xml import NSElement, parse_xml_from_string
 from .base import AbstractGeometry, GM_Envelope, GM_Object, TM_Object
 from .geometries import GEOSGMLGeometry, is_gml_element  # also do tag registration
 
-# All known root nodes as GML object:
-GmlRootNodes = Union[GM_Object, GM_Envelope, TM_Object]
-
 __all__ = [
     "GM_Object",
     "GM_Envelope",
@@ -29,27 +24,23 @@ __all__ = [
 ]
 
 
-def parse_gml(text: str | bytes) -> GmlRootNodes:
+def parse_gml(text: str | bytes) -> GM_Object | GM_Envelope | TM_Object:
     """Parse an XML <gml:...> string."""
     root_element = parse_xml_from_string(text)
     return parse_gml_node(root_element)
 
 
-def parse_gml_node(element: NSElement) -> GmlRootNodes:
-    """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}")
 
     # All known root nodes as GML object:
-    return tag_registry.node_from_xml(element, allowed_types=GmlRootNodes.__args__)
+    return tag_registry.node_from_xml(element, allowed_types=(GM_Object, GM_Envelope, TM_Object))
 
 
 def find_gml_nodes(element: NSElement) -> list[NSElement]:
-    """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
+    """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

@@ -6,29 +6,35 @@ map to the GML implementations. These names are referenced by the FES spec.
 
 from __future__ import annotations
 
-from gisserver.parsers.ast import BaseNode
+from gisserver.parsers.ast import AstNode
 from gisserver.parsers.query import CompiledQuery
 
+__all__ = (
+    "GM_Object",
+    "GM_Envelope",
+    "TM_Object",
+    "AbstractTimeObject",
+    "AbstractTimePrimitive",
+    "Envelope",
+    "AbstractGeometry",
+)
 
-class AbstractGeometry(BaseNode):
-    """Abstract base classes for all GML objects, regardless of their version.
 
-    <gml:AbstractGeometry> implements the ISO 19107 GM_Object.
-    """
+class GM_Object(AstNode):
+    """Abstract base classes for all GML objects, regardless of their version."""
 
     def build_rhs(self, compiler: CompiledQuery):
-        # Allow the value to be used in a binary operator
+        """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.
-
-    <gml:Envelope> implements ISO 19107 GM_Envelope (see D.2.3.4 and ISO 19107:2003, 6.4.3).
-    """
+class GM_Envelope(AstNode):
+    """Abstract base classes for the GML envelope, regardless of their version."""
 
 
-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)
@@ -36,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

@@ -6,15 +6,16 @@ Overview of GML 3.2 changes: https://mapserver.org/el/development/rfc/ms-rfc-105
 from dataclasses import dataclass
 from xml.etree.ElementTree import tostring
 
+from django.contrib.gis.gdal import AxisOrder
 from django.contrib.gis.geos import GEOSGeometry, Polygon
 
+from gisserver.crs import CRS
 from gisserver.exceptions import ExternalParsingError
-from gisserver.geometries import CRS
 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/"
 
@@ -71,6 +72,7 @@ class GEOSGMLGeometry(AbstractGeometry):
             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
@@ -87,11 +89,12 @@ class GEOSGMLGeometry(AbstractGeometry):
         # 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:
@@ -112,23 +115,47 @@ class GEOSGMLGeometry(AbstractGeometry):
         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")
-@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"""
+        # 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