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

gisserver/parsers/fes20/query.py

@@ -1,285 +0,0 @@
-from __future__ import annotations
-
-import operator
-from functools import reduce
-
-from django.conf import settings
-from django.contrib.gis.db.models.fields import BaseSpatialField
-from django.contrib.gis.db.models.lookups import DWithinLookup
-from django.db import models
-from django.db.models import Q, QuerySet, lookups
-from django.db.models.expressions import Combinable
-
-from gisserver.features import FeatureType
-
-from . import expressions, sorting
-
-
-class CompiledQuery:
-    """Intermediate data for translating FES queries to Django.
-
-    This class contains all data from the ``<fes:Filter>`` object in a model
-    that can be translated to a django QuerySet.
-
-    This object is passed though all build_...() methods,
-    so it can be used to add extra lookups and annotations.
-    """
-
-    def __init__(
-        self,
-        feature_type: FeatureType | None = None,
-        using: str | None = None,
-        lookups: list[Q] | None = None,
-        typed_lookups: dict[str, list[Q]] | None = None,
-        annotations: dict[str, Combinable | Q] | None = None,
-    ):
-        """The init method is typically used only in unit tests."""
-        self.feature_type = feature_type
-        self.using = using
-        self.lookups = lookups or []
-        self.typed_lookups = typed_lookups or {}
-        self.annotations = annotations or {}
-        self.aliases = 0
-        self.extra_lookups: list[Q] = []
-        self.ordering: list[str] = []
-        self.is_empty = False
-        self.distinct = False
-
-    def add_annotation(self, value: Combinable | Q) -> str:
-        """Create a named-alias for a function/Q object.
-        This alias can be used in a comparison, where expressions are used as left-hand-side.
-        """
-        self.aliases += 1
-        name = f"a{self.aliases}"
-        self.annotations[name] = value
-        return name
-
-    def add_distinct(self):
-        self.distinct = True
-
-    def add_lookups(self, q_object: Q, type_name: str | None = None):
-        """Register an extra 'WHERE' clause of the query.
-        This is used for comparisons, ID selectors and other query types.
-        """
-        if not isinstance(q_object, Q):
-            raise TypeError()
-
-        if type_name is not None:
-            if type_name not in self.typed_lookups:
-                self.typed_lookups[type_name] = []
-            self.typed_lookups[type_name].append(q_object)
-        else:
-            self.lookups.append(q_object)
-
-    def add_extra_lookup(self, q_object: Q):
-        """Temporary stash an extra lookup that the expression can't return yet.
-        This is used for XPath selectors that also filter on attributes,
-        e.g. "element[@attr=..]/child". The attribute lookup is processed as another filter.
-        """
-        if not isinstance(q_object, Q):
-            raise TypeError()
-        self.extra_lookups.append(q_object)
-
-    def add_sort_by(self, sort_by: sorting.SortBy):
-        """Read the desired result ordering from a ``<fes:SortBy>`` element."""
-        self.ordering += sort_by.build_ordering(self.feature_type)
-
-    def add_value_reference(
-        self, value_reference: expressions.ValueReference
-    ) -> expressions.RhsTypes:
-        """Add a reference that should be returned by the query.
-
-        This includes the XPath expression to the query, in case that adds
-        extra lookups. The name (or alias) is returned that can be used in the
-         ``queryset.values()`` result. This is needed to support cases like
-        these in the future: ``addresses/Address[street="Oxfordstrasse"]/number``
-        """
-        # The actual limiting of fields happens inside the decorate_queryset() of the renderer.
-        return value_reference.build_rhs(self)
-
-    def add_property_name(self, property_name: expressions.ValueReference) -> expressions.RhsTypes:
-        """Define which field should be returned by the query."""
-        # Make sure any xpath [attr=value] lookups work.
-        # This will also validate the name because it resolves the ORM path.
-        # The actual limiting of fields happens inside the decorate_queryset() of the renderer.
-        return property_name.build_rhs(self)
-
-    def apply_extra_lookups(self, comparison: Q) -> Q:
-        """Combine stashed lookups with the provided Q object.
-
-        This is called for functions that compile a "Q" object.
-        In case a node added extra lookups (for attributes), these are combined here
-        with the actual comparison.
-        """
-        if not self.extra_lookups:
-            return comparison
-
-        # The extra lookups are used for XPath queries such as "/node[@attr=..]/foo".
-        # A <ValueReference> with such lookup also requires to limit the filtered results,
-        # in addition to the comparison operator code that is wrapped up here.
-        result = reduce(operator.and_, [comparison] + self.extra_lookups)
-        self.extra_lookups.clear()
-        return result
-
-    def mark_empty(self):
-        """Mark as returning no results."""
-        self.is_empty = True
-
-    def filter_queryset(self, queryset: QuerySet, feature_type: FeatureType) -> QuerySet:
-        """Apply the filters and lookups to the queryset.
-
-        :param queryset: The queryset to filter.
-        :param feature_type: The feature type that the queryset originated from.
-        """
-        if self.is_empty:
-            return queryset.none()
-
-        if self.extra_lookups:
-            # Each time an expression node calls add_extra_lookup(),
-            # the parent should have used apply_extra_lookups()
-            raise RuntimeError("apply_extra_lookups() was not called")
-
-        # All are applied at once.
-        if self.annotations:
-            queryset = queryset.annotate(**self.annotations)
-
-        lookups = self.lookups
-        try:
-            lookups += self.typed_lookups[feature_type.name]
-        except KeyError:
-            pass
-
-        if lookups:
-            queryset = queryset.filter(*lookups)
-
-        if self.ordering:
-            queryset = queryset.order_by(*self.ordering)
-
-        if self.distinct:
-            queryset = queryset.distinct()
-
-        return queryset
-
-    def __repr__(self):
-        return (
-            "<CompiledQuery"
-            f" annotations={self.annotations!r},"
-            f" lookups={self.lookups!r},"
-            f" typed_lookups={self.typed_lookups!r}>"
-        )
-
-    def __eq__(self, other):
-        """For pytest comparisons."""
-        if isinstance(other, CompiledQuery):
-            return (
-                other.lookups == self.lookups
-                and other.typed_lookups == self.typed_lookups
-                and other.annotations == self.annotations
-            )
-        else:
-            return NotImplemented
-
-
-@models.CharField.register_lookup
-@models.TextField.register_lookup
-@models.ForeignObject.register_lookup
-class FesLike(lookups.Lookup):
-    """Allow fieldname__fes_like=... lookups in querysets."""
-
-    lookup_name = "fes_like"
-
-    def as_sql(self, compiler, connection):
-        """Generate the required SQL."""
-        # lhs = "table"."field"
-        # rhs = %s
-        # lhs_params = []
-        # lhs_params = ["prep-value"]
-        lhs, lhs_params = self.process_lhs(compiler, connection)
-        rhs, rhs_params = self.process_rhs(compiler, connection)
-        return f"{lhs} LIKE {rhs}", lhs_params + rhs_params
-
-    def get_db_prep_lookup(self, value, connection):
-        """This expects that the right-hand-side already has wildcard characters."""
-        return "%s", [value]
-
-
-@models.Field.register_lookup
-@models.ForeignObject.register_lookup
-class FesNotEqual(lookups.Lookup):
-    """Allow fieldname__fes_notequal=... lookups in querysets."""
-
-    lookup_name = "fes_notequal"
-
-    def as_sql(self, compiler, connection):
-        """Generate the required SQL."""
-        lhs, lhs_params = self.process_lhs(compiler, connection)  # = (table.field, %s)
-        rhs, rhs_params = self.process_rhs(compiler, connection)  # = ("prep-value", [])
-        return f"{lhs} != {rhs}", (lhs_params + rhs_params)
-
-
-@BaseSpatialField.register_lookup
-class FesBeyondLookup(DWithinLookup):
-    """Based on the FES 2.0.3 corrigendum:
-
-    DWithin(A,B,d) = Distance(A,B) < d
-    Beyond(A,B,d) = Distance(A,B) > d
-
-    See: https://docs.opengeospatial.org/is/09-026r2/09-026r2.html#61
-    """
-
-    lookup_name = "fes_beyond"
-    sql_template = "NOT %(func)s(%(lhs)s, %(rhs)s, %(value)s)"
-
-    def get_rhs_op(self, connection, rhs):
-        # Allow the SQL $(func)s to be different from the ORM lookup name.
-        # This uses ST_DWithin() on PostGIS
-        return connection.ops.gis_operators["dwithin"]
-
-
-if "django.contrib.postgres" in settings.INSTALLED_APPS:
-    from django.contrib.postgres.fields import ArrayField
-
-    class ArrayAnyMixin:
-        any_operators = {
-            "exact": "= ANY(%s)",
-            "ne": "!= ANY(%s)",
-            "gt": "< ANY(%s)",
-            "gte": "<= ANY(%s)",
-            "lt": "> ANY(%s)",
-            "lte": ">= ANY(%s)",
-        }
-
-        def as_sql(self, compiler, connection):
-            # For the ANY() comparison, the filter operands need to be reversed.
-            # So instead of "field < value", it becomes "value > ANY(field)
-            lhs_sql, lhs_params = self.process_lhs(compiler, connection)
-            rhs_sql, rhs_params = self.process_rhs(compiler, connection)
-            lhs_sql = self.get_rhs_op(connection, lhs_sql)
-            return f"{rhs_sql} {lhs_sql}", (rhs_params + lhs_params)
-
-        def get_rhs_op(self, connection, rhs):
-            return self.any_operators[self.lookup_name] % rhs
-
-    def _register_any_lookup(base: type[lookups.BuiltinLookup]):
-        """Register array lookups under a different name."""
-        cls = type(f"FesArrayAny{base.__name__}", (ArrayAnyMixin, base), {})
-        ArrayField.register_lookup(cls, lookup_name=f"fes_any{base.lookup_name}")
-
-    _register_any_lookup(lookups.Exact)
-    _register_any_lookup(lookups.Exact)
-    _register_any_lookup(lookups.GreaterThan)
-    _register_any_lookup(lookups.GreaterThanOrEqual)
-    _register_any_lookup(lookups.LessThan)
-    _register_any_lookup(lookups.LessThanOrEqual)
-
-    @ArrayField.register_lookup
-    class FesArrayAnyNotEqual(FesNotEqual):
-        """Inequality test for a single item in the array"""
-
-        lookup_name = "fes_anynotequal"
-
-        def as_sql(self, compiler, connection):
-            """Generate the required SQL."""
-            lhs, lhs_params = self.process_lhs(compiler, connection)
-            rhs, rhs_params = self.process_rhs(compiler, connection)
-            return f"{rhs} != ANY({lhs})", (rhs_params + lhs_params)

gisserver/parsers/tags.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-from functools import wraps
-from itertools import chain
-from typing import TYPE_CHECKING
-from xml.etree.ElementTree import Element, QName
-
-from gisserver.exceptions import ExternalParsingError
-
-
-def expect_tag(namespace: str, *tag_names: str, leaf=False):
-    """Validate whether a given tag is need"""
-    valid_tags = {str(QName(namespace, name)) for name in tag_names}
-    expect0 = str(QName(namespace, tag_names[0]))
-
-    def _wrapper(func):
-        @wraps(func)
-        def _expect_tag_decorator(cls, element: Element, *args, **kwargs):
-            if element.tag not in valid_tags:
-                raise ExternalParsingError(
-                    f"{cls.__name__} parser expects an <{expect0}> node, got <{element.tag}>"
-                )
-            if leaf and len(element):
-                raise ExternalParsingError(
-                    f"Unsupported child element for {element.tag} element: {element[0].tag}."
-                )
-
-            return func(cls, element, *args, **kwargs)
-
-        return _expect_tag_decorator
-
-    return _wrapper
-
-
-def expect_children(min_child_nodes, *expect_types: str | type[BaseNode]):
-    def _wrapper(func):
-        @wraps(func)
-        def _expect_children_decorator(cls, element: Element, *args, **kwargs):
-            if len(element) < min_child_nodes:
-                type_names = ", ".join(
-                    sorted(
-                        set(
-                            chain.from_iterable(
-                                (
-                                    [child_type]
-                                    if isinstance(child_type, str)
-                                    else chain.from_iterable(
-                                        sub_type.xml_tags
-                                        for sub_type in child_type.__subclasses__()
-                                    )
-                                )
-                                for child_type in expect_types
-                            )
-                        )
-                    )
-                )
-                suffix = f" (possible tags: {type_names})" if type_names else ""
-                raise ExternalParsingError(
-                    f"<{element.tag}> should have {min_child_nodes} child nodes, "
-                    f"got {len(element)}{suffix}"
-                )
-
-            return func(cls, element, *args, **kwargs)
-
-        return _expect_children_decorator
-
-    return _wrapper
-
-
-def get_child(root, namespace, localname) -> Element:
-    """Find the element using a fully qualified name."""
-    return root.find(QName(namespace, localname).text)
-
-
-def get_children(root, namespace, localname) -> list[Element]:
-    """Find the element using a fully qualified name."""
-    return root.findall(QName(namespace, localname).text)
-
-
-def get_attribute(element: Element, name) -> str:
-    """Resolve an attribute, raise an error when it's missing."""
-    try:
-        return element.attrib[name]
-    except KeyError:
-        raise ExternalParsingError(
-            f"Element {element.tag} misses required attribute '{name}'"
-        ) from None
-
-
-def split_ns(tag_name: str) -> tuple[str | None, str]:
-    """Split the element tag into the namespace and local name.
-    The stdlib etree doesn't have the properties for this (lxml does).
-    """
-    if tag_name.startswith("{"):
-        end = tag_name.index("}")
-        return tag_name[1:end], tag_name[end + 1 :]
-    else:
-        return None, tag_name
-
-
-if TYPE_CHECKING:
-    from gisserver.parsers.base import BaseNode

gisserver/queries/__init__.py

@@ -1,37 +0,0 @@
-"""Entry point to handle queries.
-
-WFS defines 2 query types:
-- Adhoc queries are constructed directly from request parameters.
-- Stored queries are defined first, and executed later.
-
-Both use the FES (Filter Encoding Syntax) filtering logic internally.
-
-The objects in this module closely follow the WFS spec.
-By using the same type definitions, a lot of code logic follows naturally.
-The "GetFeatureById" is a mandatory built-in stored query.
-"""
-
-from .adhoc import AdhocQuery
-from .base import QueryExpression
-from .projection import FeatureProjection, FeatureRelation
-from .stored import (
-    GetFeatureById,
-    QueryExpressionText,
-    StoredQuery,
-    StoredQueryDescription,
-    StoredQueryParameter,
-    stored_query_registry,
-)
-
-__all__ = (
-    "QueryExpression",
-    "AdhocQuery",
-    "QueryExpressionText",
-    "StoredQueryDescription",
-    "StoredQuery",
-    "stored_query_registry",
-    "StoredQueryParameter",
-    "GetFeatureById",
-    "FeatureProjection",
-    "FeatureRelation",
-)

gisserver/queries/adhoc.py

@@ -1,185 +0,0 @@
-"""Handle adhoc-query objects.
-
-The adhoc query is based on incoming request parameters,
-such as the "FILTER", "BBOX" and "RESOURCEID" parameters.
-
-These definitions follow the WFS spec.
-"""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-
-from django.db.models import Q
-
-from gisserver import conf
-from gisserver.exceptions import InvalidParameterValue, MissingParameterValue
-from gisserver.features import FeatureType
-from gisserver.geometries import BoundingBox
-from gisserver.parsers import fes20
-from gisserver.parsers.fes20 import operators
-
-from .base import QueryExpression
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class AdhocQuery(QueryExpression):
-    """The Ad hoc query expression parameters.
-
-    This represents all dynamic queries received as request (hence "adhoc"),
-    such as the "FILTER" and "BBOX" arguments from an HTTP GET.
-
-    The WFS Spec has 3 class levels for this:
-    - AdhocQueryExpression (types, projection, selection, sorting)
-    - Query (adds srsName, featureVersion)
-
-    For KVP requests, this dataclass is almost identical to **params.
-    However, it allows combining the filter parameters. These become
-    one single XML request for HTTP POST requests later.
-
-    .. seealso::
-        https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/query_xsd.html#AbstractAdhocQueryExpressionType
-    """
-
-    typeNames: list[FeatureType]  # typeNames in WFS/FES spec
-    # aliases: Optional[List[str]] = None
-    handle: str = ""  # only for XML POST requests
-
-    # Projection clause (fes:AbstractProjectionClause)
-    property_names: list[fes20.ValueReference] | None = None
-
-    # Selection clause (fes:AbstractSelectionClause):
-    # - for XML POST this is encoded in a <fes:Query>
-    # - for HTTP GET, this is encoded as FILTER, FILTER_LANGUAGE, RESOURCEID, BBOX.
-    filter: fes20.Filter | None = None
-    filter_language: str = fes20.Filter.query_language
-    bbox: BoundingBox | None = None
-
-    # Sorting Clause (fes:AbstractSortingClause)
-    sortBy: fes20.SortBy | None = None
-
-    # Officially part of the GetFeature/GetPropertyValue request object,
-    # but included here for ease of query implementation.
-    resourceId: fes20.IdOperator | None = None
-
-    # GetPropertyValue:
-    # In the WFS spec, this is only part of the operation/presentation.
-    # For Django, we'd like to make this part of the query too.
-    value_reference: fes20.ValueReference | None = None
-
-    @classmethod
-    def from_kvp_request(cls, **params):
-        """Build this object from an HTTP GET (key-value-pair) request."""
-        # Validate optionally required parameters
-        if not params["typeNames"] and not params["resourceID"]:
-            raise MissingParameterValue("Empty TYPENAMES parameter", locator="typeNames")
-
-        # Validate mutually exclusive parameters
-        if params["filter"] and (params["bbox"] or params["resourceID"]):
-            raise InvalidParameterValue(
-                "The FILTER parameter is mutually exclusive with BBOX and RESOURCEID",
-                locator="filter",
-            )
-
-        # Validate mutually exclusive parameters
-        if params["resourceID"]:
-            if params["bbox"] or params["filter"]:
-                raise InvalidParameterValue(
-                    "The RESOURCEID parameter is mutually exclusive with BBOX and FILTER",
-                    locator="resourceID",
-                )
-
-            # When ResourceId + typenames is defined, it should be a value from typenames
-            # see WFS spec 7.9.2.4.1
-            if params["typeNames"]:
-                id_type_names = params["resourceID"].type_names
-                if id_type_names:
-                    # Only test when the RESOURCEID has a typename.id format
-                    # Otherwise, this breaks the CITE RESOURCEID=test-UUID parameter.
-                    kvp_type_names = {feature_type.name for feature_type in params["typeNames"]}
-                    if not kvp_type_names.issuperset(id_type_names):
-                        raise InvalidParameterValue(
-                            "When TYPENAMES and RESOURCEID are combined, "
-                            "the RESOURCEID type should be included in TYPENAMES.",
-                            locator="resourceID",
-                        )
-
-        return AdhocQuery(
-            typeNames=params["typeNames"],
-            property_names=params["propertyName"],
-            filter=params["filter"],
-            filter_language=params["filter_language"],
-            bbox=params["bbox"],
-            sortBy=params["sortBy"],
-            resourceId=params["resourceID"],
-            value_reference=params.get("valueReference"),
-        )
-
-    def bind(self, *args, **kwargs):
-        """Inform this query object of the available feature types"""
-        super().bind(*args, **kwargs)
-
-        if self.resourceId:
-            # Early validation whether the selected resourceID type exists.
-            feature_types = [
-                self.resolve_type_name(type_name, locator="resourceID")
-                for type_name in self.resourceId.type_names
-            ]
-
-            # Also make the behavior consistent, always supply the type name.
-            if not self.typeNames:
-                self.typeNames = feature_types
-
-    def get_type_names(self):
-        return self.typeNames
-
-    def compile_query(self, feature_type: FeatureType, using=None) -> fes20.CompiledQuery:
-        """Return our internal CompiledQuery object that can be applied to the queryset."""
-        if self.filter:
-            # Generate the internal query object from the <fes:Filter>
-            return self.filter.compile_query(feature_type, using=using)
-        else:
-            # Generate the internal query object from the BBOX and sortBy args.
-            return self._compile_non_filter_query(feature_type, using=using)
-
-    def _compile_non_filter_query(self, feature_type: FeatureType, using=None):
-        """Generate the query based on the remaining parameters.
-
-        This is slightly more efficient than generating the fes Filter object
-        from these KVP parameters (which could also be done within the request method).
-        """
-        compiler = fes20.CompiledQuery(feature_type=feature_type, using=using)
-
-        if self.bbox:
-            # Validate whether the provided SRID is supported.
-            # While PostGIS would support many more ID's,
-            # it would crash when an unsupported ID is given.
-            crs = self.bbox.crs
-            if (
-                conf.GISSERVER_SUPPORTED_CRS_ONLY
-                and crs is not None
-                and crs not in feature_type.supported_crs
-            ):
-                raise InvalidParameterValue(
-                    "bbox",
-                    f"Feature '{feature_type.name}' does not support SRID {crs.srid}.",
-                )
-
-            # Using __within does not work with geometries
-            # that only partially exist within the bbox
-            lookup = operators.SpatialOperatorName.BBOX.value  # "intersects"
-            filters = {
-                f"{feature_type.geometry_field.name}__{lookup}": self.bbox.as_polygon(),
-            }
-            compiler.add_lookups(Q(**filters))
-
-        if self.resourceId:
-            self.resourceId.build_query(compiler=compiler)
-
-        if self.sortBy:
-            compiler.add_sort_by(self.sortBy)
-
-        return compiler