django-gisserver 2.1__tar.gz → 2.1.1__tar.gz

{django_gisserver-2.1 → django_gisserver-2.1.1}/CHANGES.md

@@ -1,3 +1,13 @@
+# 2025-06-06 (2.1.1)
+
+* Fixed using legacy longitude/latitude rendering for `EPSG:4326` and `:http://www.opengis.net/gml/srs/epsg.xml#xxxx` SRS names.
+* Improved styling for the default HTML page.
+
+This increases interoperability with web-based clients and legacy libraries. GeoServer applies the same heuristic.
+Clients that use the official OGC notations such as `urn:ogc:def:crs:EPSG::4326` and `http://www.opengis.net/def/crs/epsg/0/4326`
+are not affected. If needed, this behavior can be disabled using `GISSERVER_FORCE_XY_EPSG_4326=False` and `GISSERVER_FORCE_XY_OLD_CRS=False`.
+
+
 # 2025-05-29 (2.1)
 
 * Added support for `ArrayField` field in CSV exports.

{django_gisserver-2.1/django_gisserver.egg-info → django_gisserver-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-gisserver
-Version: 2.1
+Version: 2.1.1
 Summary: Django speaking WFS 2.0 (exposing GeoDjango model fields)
 Home-page: https://github.com/amsterdam/django-gisserver
 Author: Diederik van der Boor
@@ -46,6 +46,7 @@ Requires-Dist: pytest-cov>=2.11.1; extra == "tests"
 Provides-Extra: docs
 Requires-Dist: Django~=5.0; extra == "docs"
 Requires-Dist: sphinxcontrib-django>=2.5; extra == "docs"
+Requires-Dist: myst-parser>=3.0.1; extra == "docs"
 Requires-Dist: psycopg2-binary>=2.8.4; extra == "docs"
 Dynamic: author
 Dynamic: author-email

{django_gisserver-2.1 → django_gisserver-2.1.1/django_gisserver.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-gisserver
-Version: 2.1
+Version: 2.1.1
 Summary: Django speaking WFS 2.0 (exposing GeoDjango model fields)
 Home-page: https://github.com/amsterdam/django-gisserver
 Author: Diederik van der Boor
@@ -46,6 +46,7 @@ Requires-Dist: pytest-cov>=2.11.1; extra == "tests"
 Provides-Extra: docs
 Requires-Dist: Django~=5.0; extra == "docs"
 Requires-Dist: sphinxcontrib-django>=2.5; extra == "docs"
+Requires-Dist: myst-parser>=3.0.1; extra == "docs"
 Requires-Dist: psycopg2-binary>=2.8.4; extra == "docs"
 Dynamic: author
 Dynamic: author-email

{django_gisserver-2.1 → django_gisserver-2.1.1}/django_gisserver.egg-info/requires.txt

@@ -7,6 +7,7 @@ pyproj>=3.6.1
 [docs]
 Django~=5.0
 sphinxcontrib-django>=2.5
+myst-parser>=3.0.1
 psycopg2-binary>=2.8.4
 
 [tests]

django_gisserver-2.1.1/gisserver/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1.1"  # follows PEP440

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/conf.py

@@ -4,6 +4,8 @@ from django.conf import settings
 from django.core.signals import setting_changed
 from django.dispatch import receiver
 
+_originals = {}
+
 # -- feature flags
 
 # Configure whether the <ows:WGS84BoundingBox> should be included in GetCapabilities.
@@ -30,6 +32,17 @@ GISSERVER_COUNT_NUMBER_MATCHED = getattr(settings, "GISSERVER_COUNT_NUMBER_MATCH
 
 # -- output rendering
 
+# Following https://docs.geoserver.org/stable/en/user/services/wfs/axis_order.html here:
+# Whether the older EPSG:4326 notation (instead of the OGC recommended styles)
+# should render in legacy longitude/latitude (x/y) ordering.
+# This increases interoperability with legacy web clients,
+# as others use urn:ogc:def:crs:EPSG::4326 or http://www.opengis.net/def/crs/epsg/0/4326.
+GISSERVER_FORCE_XY_EPSG_4326 = getattr(settings, "GISSERVER_FORCE_XY_EPSG_4326", True)
+
+# Whether the legacy CRS notation http://www.opengis.net/gml/srs/epsg.xml# should render in X/Y
+GISSERVER_FORCE_XY_OLD_CRS = getattr(settings, "GISSERVER_FORCE_XY_OLD_CRS", True)
+
+# Extra output formats for GetFeature (see documentation for details)
 GISSERVER_EXTRA_OUTPUT_FORMATS = getattr(settings, "GISSERVER_EXTRA_OUTPUT_FORMATS", {})
 GISSERVER_GET_FEATURE_OUTPUT_FORMATS = getattr(
     settings, "GISSERVER_GET_FEATURE_OUTPUT_FORMATS", {}
@@ -59,4 +72,13 @@ def _on_settings_change(setting, value, enter, **kwargs):
     if not setting.startswith("GISSERVER_"):
         return
 
-    globals()[setting] = value
+    conf_module = globals()
+    if value is None and not enter:
+        # override_settings().disable() returns what the django settings module had.
+        # Revert to our defaults here instead.
+        value = _originals.get(setting)
+    else:
+        # Track defaults of this file for reverting to them
+        _originals.setdefault(setting, conf_module[setting])
+
+    conf_module[setting] = value

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/crs.py

@@ -15,6 +15,7 @@ import pyproj
 from django.contrib.gis.gdal import AxisOrder, CoordTransform, OGRGeometry, SpatialReference
 from django.contrib.gis.geos import GEOSGeometry
 
+from gisserver import conf
 from gisserver.exceptions import ExternalValueError
 
 CRS_URN_REGEX = re.compile(
@@ -36,7 +37,7 @@ __all__ = [
 ]
 
 # Caches to avoid reinitializing WGS84 each time.
-_COMMON_CRS_BY_URN = {}
+_COMMON_CRS_BY_STR = {}
 _COMMON_CRS_BY_SRID = {}
 
 
@@ -74,7 +75,7 @@ _get_proj_crs_from_string = lru_cache(maxsize=10)(pyproj.CRS.from_string)
 _get_proj_crs_from_authority = lru_cache(maxsize=10)(pyproj.CRS.from_authority)
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=False)
 class CRS:
     """
     Represents a CRS (Coordinate Reference System), which preferably follows the URN format
@@ -110,6 +111,9 @@ class CRS:
     #: Original input
     origin: str = field(init=False, default=None)
 
+    #: Tell whether the input format used the legacy notation.
+    force_xy: bool = False
+
     @classmethod
     def from_string(cls, uri: str | int) -> CRS:
         """
@@ -123,12 +127,15 @@ class CRS:
         * A legacy CRS URI ("epsg:<SRID>", or "http://www.opengis.net/...").
         * A numeric SRID (which calls :meth:`from_srid()`)
         """
+        if known_crs := _COMMON_CRS_BY_STR.get(uri):
+            return known_crs  # Avoid object re-creation
+
         if isinstance(uri, int) or uri.isdigit():
             return cls.from_srid(int(uri))
         elif uri.startswith("urn:"):
             return cls._from_urn(uri)
         else:
-            return cls._from_legacy(uri)
+            return cls._from_prefix(uri)
 
     @classmethod
     def from_srid(cls, srid: int):
@@ -141,22 +148,19 @@ class CRS:
         if common_crs := _COMMON_CRS_BY_SRID.get(srid):
             return common_crs  # Avoid object re-creation
 
-        crs = cls(
+        return cls(
             domain="ogc",
             authority="EPSG",
             version="",
             crsid=str(srid),
             srid=int(srid),
         )
-        crs.__dict__["origin"] = srid
-        return crs
 
     @classmethod
     def _from_urn(cls, urn):  # noqa: C901
-        """Instantiate this class using a URN format."""
-        if known_crs := _COMMON_CRS_BY_URN.get(urn):
-            return known_crs  # Avoid object re-creation
-
+        """Instantiate this class using a URN format.
+        This format is defined in https://portal.ogc.org/files/?artifact_id=30575.
+        """
         urn_match = CRS_URN_REGEX.match(urn)
         if not urn_match:
             raise ExternalValueError(f"Unknown CRS URN [{urn}] specified: {CRS_URN_REGEX.pattern}")
@@ -187,7 +191,7 @@ class CRS:
         crs = cls(
             domain=domain,
             authority=authority,
-            version=urn_match.group(3),
+            version=urn_match.group(3) or "",
             crsid=crsid,
             srid=srid,
         )
@@ -195,16 +199,30 @@ class CRS:
         return crs
 
     @classmethod
-    def _from_legacy(cls, uri):
-        """Instantiate this class from a legacy URL"""
-        luri = uri.lower()
-        for head in (
-            "epsg:",
-            "http://www.opengis.net/def/crs/epsg/0/",
-            "http://www.opengis.net/gml/srs/epsg.xml#",
+    def _from_prefix(cls, uri):
+        """Instantiate this class from a non-URI notation.
+
+        The modern URL format (:samp:`http://www.opengis.net/def/crs/epsg/0/{xxxx}`)
+        is defined in https://portal.ogc.org/files/?artifact_id=46361.
+
+        Older notations like :samp:`EPSG:{xxxx}` or legacy XML URLs like
+        and :samp`:http://www.opengis.net/gml/srs/epsg.xml#{xxxx}` are also supported.
+        """
+        # Make sure origin uses the expected upper/lowercasing.
+        origin = uri.lower() if "://" in uri else uri.upper()
+        for prefix, force_xy in (
+            (
+                "EPSG:",
+                (conf.GISSERVER_FORCE_XY_EPSG_4326 and origin == "EPSG:4326"),
+            ),
+            (
+                "http://www.opengis.net/gml/srs/epsg.xml#",
+                conf.GISSERVER_FORCE_XY_OLD_CRS,
+            ),
+            ("http://www.opengis.net/def/crs/epsg/0/", False),
         ):
-            if luri.startswith(head):
-                crsid = luri[len(head) :]
+            if origin.startswith(prefix):
+                crsid = origin[len(prefix) :]
                 try:
                     srid = int(crsid)
                 except ValueError:
@@ -218,16 +236,19 @@ class CRS:
                     version="",
                     crsid=crsid,
                     srid=srid,
+                    force_xy=force_xy,
                 )
-                crs.__dict__["origin"] = uri
+                crs.__dict__["origin"] = origin
                 return crs
 
         raise ExternalValueError(f"Unknown CRS URI [{uri}] specified")
 
     @property
     def legacy(self):
-        """Return a legacy string in the format :samp:`EPSG:{srid}`."""
-        return f"EPSG:{self.srid:d}"
+        """Return a legacy string in the format :samp:`http://www.opengis.net/gml/srs/epsg.xml#{srid}`."""
+        # This mirrors what GeoSever does, as this notation always has an axis ordering defined.
+        # Notations like EPSG:xxxx notation don't have such consistent usage.
+        return f"http://www.opengis.net/gml/srs/epsg.xml#{self.srid:d}"
 
     @cached_property
     def urn(self):
@@ -254,16 +275,29 @@ class CRS:
         return [axis.direction for axis in proj_crs.axis_info]
 
     def __str__(self):
-        return self.urn
+        return self.legacy if self.force_xy else self.urn
 
     def __eq__(self, other):
         if isinstance(other, CRS):
-            # CRS84 is NOT equivalent to EPSG:4326.
-            # EPSG:4326 specifies coordinates in lat/long order and CRS84 in long/lat order.
-            return self.authority == other.authority and self.srid == other.srid
+            return self.matches(other, compare_legacy=True)
         else:
             return NotImplemented
 
+    def matches(self, other, compare_legacy=True) -> bool:
+        """Tell whether this CRS is identical to another one."""
+        return (
+            # "urn:ogc:def:crs:EPSG::4326" != "urn:ogc:def:crs:OGC::CRS84"
+            # even through they both share the same srid.
+            self.srid == other.srid
+            and self.authority == other.authority
+            and (
+                # Also, legacy notations like EPSG:4326 are treated differently,
+                # unless this is configured to not make a difference.
+                not compare_legacy
+                or self.force_xy == other.force_xy
+            )
+        )
+
     def __hash__(self):
         """Used to match objects in a set."""
         return hash((self.authority, self.srid))
@@ -272,7 +306,8 @@ class CRS:
         """Generate the GDAL Spatial Reference object."""
         if self.backends[axis_order] is None:
             backends = list(self.backends)
-            if self.origin:
+            if self.origin and "://" not in self.origin:  # avoid downloads and OGR errors
+                # Passing the origin helps to detect CRS84 strings
                 backends[axis_order] = _get_spatial_reference(self.origin, "user", axis_order)
             else:
                 backends[axis_order] = _get_spatial_reference(self.srid, "epsg", axis_order)
@@ -284,7 +319,12 @@ class CRS:
 
     def _as_proj(self) -> pyproj.CRS:
         """Generate the PROJ CRS object"""
-        if isinstance(self.origin, str) and not self.origin.isdigit():
+        if (
+            isinstance(self.origin, str)
+            and not self.origin.isdigit()
+            and "epsg.xml#" not in self.origin  # not supported
+        ):
+            # Passing the origin helps to detect CRS84 strings
             return _get_proj_crs_from_string(self.origin)
         else:
             return _get_proj_crs_from_authority(self.authority, self.srid)
@@ -293,7 +333,7 @@ class CRS:
         self,
         geometry: AnyGeometry,
         clone=False,
-        axis_order: AxisOrder = AxisOrder.AUTHORITY,
+        axis_order: AxisOrder | None = None,
     ) -> AnyGeometry | None:
         """Transform the geometry using this coordinate reference.
 
@@ -322,6 +362,12 @@ class CRS:
         * PostGIS stores the data in x/y.
         * WFS 1.0 used x/y, WFS 1.3 used y/x except for ``EPSG:4326``.
 
+        When receiving legacy notations (e.g. ``EPSG:4326`` instead of ``urn:ogc:def:crs:EPSG::4326``),
+        the data is still projected in legacy ordering, unless ``GISSERVER_FORCE_XY_...`` is disabled.
+        This reflects the design of `GeoServer Axis Ordering
+        <https://docs.geoserver.org/stable/en/user/services/wfs/axis_order.html>`_
+        to have maximum interoperability with legacy/JavaScript clients.
+
         After GDAL/OGR changed the axis orientation, that information is
         lost when the return value is loaded back into GEOS.
         To address this, :meth:`tag_geometry` is called on the result.
@@ -331,6 +377,11 @@ class CRS:
                       For GEOS->GDAL->GEOS conversions, this makes no difference in efficiency.
         :param axis_order: Which axis ordering to convert the geometry into (depends on the use-case).
         """
+        if axis_order is None:
+            # This transforms by default to WFS 2 axis ordering (e.g. latitude/longitude),
+            # unless a legacy notation is used (e.g. EPSG:4326).
+            axis_order = AxisOrder.TRADITIONAL if self.force_xy else AxisOrder.AUTHORITY
+
         if isinstance(geometry, OGRGeometry):
             transform = _get_coord_transform(geometry.srs, self._as_gdal(axis_order=axis_order))
             return geometry.transform(transform, clone=clone)
@@ -377,12 +428,12 @@ class CRS:
         This also makes sure that requests which use the same URN will get our CRS object
         version, instead of a fresh new one.
         """
-        if self.authority == "EPSG":
+        if self.authority == "EPSG" and self.srid != 4326:
             # Only register for EPSG to avoid conflicting axis ordering issues.
-            # (WGS84 and CRS84 both use srid 4326)
+            # (WGS84 and CRS84 both use srid 4326, and the 'EPSG:4326' notation is treated as legacy)
             _COMMON_CRS_BY_SRID[self.srid] = self
 
-        _COMMON_CRS_BY_URN[self.urn] = self
+        _COMMON_CRS_BY_STR[str(self)] = self
 
 
 #: Worldwide GPS, latitude/longitude (y/x). https://epsg.io/4326

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/db.py

@@ -42,16 +42,22 @@ class AsGML(functions.AsGML):
         precision=conf.GISSERVER_DB_PRECISION,
         envelope=False,
         is_latlon=False,
+        long_urn=False,
         **extra,
     ):
         # Note that Django's AsGml the defaults are: version=2, precision=8
         super().__init__(expression, version, precision, **extra)
         self.envelope = envelope
         self.is_latlon = is_latlon
+        self.long_urn = long_urn
 
     def as_postgresql(self, compiler, connection, **extra_context):
         # Fill options parameter (https://postgis.net/docs/ST_AsGML.html)
-        options = 33 if self.envelope else 1  # 32 = bbox, 1 = long CRS urn
+        options = 0
+        if self.long_urn:
+            options |= 1  # long CRS urn
+        if self.envelope:
+            options |= 32  # bbox
         if self.is_latlon:
             # PostGIS provides the data in longitude/latitude format (east/north to look like x/y).
             # However, WFS 2.0 fixed their axis by following the authority. The ST_AsGML() doesn't

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/features.py

@@ -846,19 +846,24 @@ class FeatureType:
 
     def resolve_crs(self, crs: CRS, locator="") -> CRS:
         """Check a parsed CRS against the list of supported types."""
-        try:
-            pos = self.supported_crs.index(crs)
-
-            # Replace the parsed CRS with the declared one, which may have a 'backend' configured.
-            return self.supported_crs[pos]
-        except ValueError:
-            if conf.GISSERVER_SUPPORTED_CRS_ONLY:
-                raise InvalidParameterValue(
-                    f"Feature '{self.name}' does not support SRID {crs.srid}.",
-                    locator=locator,
-                ) from None
-            else:
-                return crs
+        for candidate in self.supported_crs:
+            # Not using self.supported_crs.index(crs), as that depends on CRS.__eq__():
+            if candidate.matches(crs, compare_legacy=False):
+                if candidate.force_xy != crs.force_xy:
+                    # user provided legacy CRS, allow output in legacy CRS
+                    return crs
+                else:
+                    # Replace the parsed CRS with the declared one.
+                    return candidate
+
+        # No match found
+        if conf.GISSERVER_SUPPORTED_CRS_ONLY:
+            raise InvalidParameterValue(
+                f"Feature '{self.name}' does not support CRS '{crs}'.",
+                locator=locator,
+            ) from None
+        else:
+            return crs
 
 
 class HDict(dict):

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/geometries.py

@@ -27,7 +27,7 @@ class BoundingBox:
     Due to the overlap between 2 types, this element is used for 2 cases:
 
     * The ``<ows:WGS84BoundingBox>`` element for ``GetCapabilities``.
-    * The ``<gml:Envelope>`` inside an``<gml:boundedBy>``  single feature.
+    * The ``<gml:Envelope>`` inside an ``<gml:boundedBy>``  single feature.
 
     While both classes have no common base class (and exist in different schema's),
     their properties are identical.

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/output/gml32.py

@@ -11,6 +11,7 @@ much extra method calls per field. Some bits are non-DRY inlined for this reason
 from __future__ import annotations
 
 import itertools
+import re
 from collections import defaultdict
 from datetime import date, datetime, time, timezone
 from decimal import Decimal as D
@@ -23,6 +24,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.db import models
 from django.http import HttpResponse
 
+from gisserver.crs import CRS84
 from gisserver.db import (
     AsGML,
     get_db_geometry_target,
@@ -46,6 +48,7 @@ from .utils import (
 )
 
 GML_RENDER_FUNCTIONS = {}
+RE_SRS_NAME = re.compile(r'srsName="([^"]+)"')
 
 
 def register_geos_type(geos_type):
@@ -232,6 +235,15 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
 
             for sub_collection in collection.results:
                 projection = sub_collection.projection
+                if projection.output_crs.force_xy and projection.output_crs.is_north_east_order:
+                    self._write(
+                        "<!--\n"
+                        f" NOTE: you are requesting the legacy projection notation '{tag_escape(projection.output_crs.origin)}'."
+                        f" Please use '{tag_escape(projection.output_crs.urn)}' instead.\n\n"
+                        " This also means output coordinates are ordered in legacy the 'west, north' axis ordering.\n"
+                        "\n-->\n"
+                    )
+
                 self.start_collection(sub_collection)
                 if has_multiple_collections:
                     self._write(
@@ -405,7 +417,7 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
         This uses an internal object type,
         as :mod:`django.contrib.gis.geos` only provides a 4-tuple envelope.
         """
-        return f"""<gml:boundedBy><gml:Envelope srsDimension="2" srsName="{attr_escape(envelope.crs.urn)}">
+        return f"""<gml:boundedBy><gml:Envelope srsDimension="2" srsName="{attr_escape(str(envelope.crs))}">
             <gml:lowerCorner>{envelope.min_x} {envelope.min_y}</gml:lowerCorner>
             <gml:upperCorner>{envelope.max_x} {envelope.max_y}</gml:upperCorner>
           </gml:Envelope></gml:boundedBy>\n"""
@@ -419,7 +431,7 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
     ) -> str:
         """Normal case: 'value' is raw geometry data.."""
         # In case this is a standalone response, this will be the top-level element, hence includes the xmlns.
-        base_attrs = f' gml:id="{attr_escape(gml_id)}" srsName="{attr_escape(projection.output_crs.urn)}"{extra_xmlns}'
+        base_attrs = f' gml:id="{attr_escape(gml_id)}" srsName="{attr_escape(str(projection.output_crs))}"{extra_xmlns}'
         projection.output_crs.apply_to(value)
         return self._render_gml_type(value, base_attrs=base_attrs)
 
@@ -521,11 +533,11 @@ class DBGMLRenderingMixin:
         id_pos = gml_tag.find("gml:id=")
         if id_pos == -1:
             # Inject
-            return f'{gml_tag} gml:id="{attr_escape(gml_id)}"{extra_xmlns}{value[end_pos:]}'
+            gml = f'{gml_tag} gml:id="{attr_escape(gml_id)}"{extra_xmlns}{value[end_pos:]}'
         else:
             # Replace
             end_pos1 = gml_tag.find('"', id_pos + 8)
-            return (
+            gml = (
                 f"{gml_tag[:id_pos]}"
                 f'gml:id="{attr_escape(gml_id)}'
                 f"{value[end_pos1:end_pos]}"  # from " right until >
@@ -533,6 +545,23 @@ class DBGMLRenderingMixin:
                 f"{value[end_pos:]}"  # from > and beyond
             )
 
+        return self._fix_db_crs_name(projection, gml)
+
+    def _fix_db_crs_name(self, projection: FeatureProjection, gml: str) -> str:
+        if projection.output_crs.force_xy:
+            # When legacy output is used, make sure the srsName matches the input.
+            # PostgreSQL will still generate the EPSG:xxxx notation.
+            return gml.replace(
+                'srsName="EPSG:', 'srsName="http://www.opengis.net/gml/srs/epsg.xml#', 1
+            )
+        elif projection.output_crs == CRS84:
+            # Fix PostgreSQL not knowing it's CRS84 or WGS84 (both srid 4326)
+            return gml.replace(
+                'srsName="urn:ogc:def:crs:EPSG::4326"', 'srsName="urn:ogc:def:crs:OGC::CRS84"', 1
+            )
+        else:
+            return gml
+
 
 class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
     """Faster GetFeature renderer that uses the database to render GML 3.2"""
@@ -553,12 +582,14 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
         # Retrieve geometries as pre-rendered instead.
         # Only take the geometries of the current level.
         # The annotations for relations will be handled by prefetches and get_prefetch_queryset()
+        use_modern = not projection.output_crs.force_xy
         return replace_queryset_geometries(
             queryset,
             projection.geometry_elements,
             projection.output_crs,
             AsGML,
-            is_latlon=projection.output_crs.is_north_east_order,
+            is_latlon=use_modern and projection.output_crs.is_north_east_order,
+            long_urn=use_modern,
         )
 
     def get_prefetch_queryset(
@@ -572,12 +603,14 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
             return None
 
         # Find which fields are GML elements
+        use_modern = not projection.output_crs.force_xy
         return replace_queryset_geometries(
             queryset,
             feature_relation.geometry_elements,
             projection.output_crs,
             AsGML,
-            is_latlon=projection.output_crs.is_north_east_order,
+            is_latlon=use_modern and projection.output_crs.is_north_east_order,
+            long_urn=use_modern,
         )
 
     def get_db_envelope_as_gml(self, projection: FeatureProjection, queryset) -> AsGML:
@@ -586,10 +619,12 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
         This also avoids offloads the geometry union calculation to the DB.
         """
         geo_fields_union = self._get_geometries_union(projection, queryset)
+        use_modern = not projection.output_crs.force_xy
         return AsGML(
             geo_fields_union,
             envelope=True,
-            is_latlon=projection.output_crs.is_north_east_order,
+            is_latlon=use_modern and projection.output_crs.is_north_east_order,
+            long_urn=use_modern,
         )
 
     def _get_geometries_union(self, projection: FeatureProjection, queryset):
@@ -620,6 +655,8 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
             gml = instance._as_envelope_gml
             if gml is None:
                 return
+
+            gml = self._fix_db_crs_name(projection, gml)
         else:
             value = get_db_rendered_geometry(instance, geo_element, AsGML)
             if value is None:
@@ -750,11 +787,13 @@ class DBGML32ValueRenderer(DBGMLRenderingMixin, GML32ValueRenderer):
         if element.type.is_geometry:
             # Add 'gml_member' to point to the pre-rendered GML version.
             geo_element = cast(GeometryXsdElement, element)
+            use_modern = not projection.output_crs.force_xy
             return queryset.values(
                 "pk",
                 gml_member=AsGML(
                     get_db_geometry_target(geo_element, projection.output_crs),
-                    is_latlon=projection.output_crs.is_north_east_order,
+                    is_latlon=use_modern and projection.output_crs.is_north_east_order,
+                    long_urn=use_modern,
                 ),
             )
         else:

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/parsers/ast.py

@@ -6,7 +6,7 @@ For example, the FES filter syntax can be processed into objects that build an O
 Python classes can inherit :class:`AstNode` and register themselves as the parser/handler
 for a given tag. Both normal Python classes and dataclass work,
 as long as it has an :meth:`AstNode.from_xml` class method.
-The custom `from_xml()` method should copy the XML data into local attributes.
+The custom ``from_xml()`` method should copy the XML data into local attributes.
 
 Next, when :meth:`TagRegistry.node_from_xml` is called,
 it will detect which class the XML Element refers to and initialize it using the ``from_xml()`` call.
@@ -58,7 +58,7 @@ class TagNameEnum(Enum):
         """Cast the element tag name into the enum member.
 
         This translates the element name
-        such as``{http://www.opengis.net/fes/2.0}PropertyIsEqualTo``
+        such as ``{http://www.opengis.net/fes/2.0}PropertyIsEqualTo``
         into a ``PropertyIsEqualTo`` member.
         """
         tag_name = element.tag
@@ -90,6 +90,7 @@ class AstNode:
     an XML tag into a Python (data) class.
     """
 
+    #: Default namespace of the element and subclasses, if not given by ``@tag_registry.register()``.
     xml_ns: xmlns | str | None = None
 
     _xml_tags = []
@@ -99,6 +100,8 @@ class AstNode:
         """Tell the default tag by which this class is registered"""
         return cls._xml_tags[0]
 
+    xml_name.__doc__ = "Tell the default tag by which this class is registered"
+
     def __init_subclass__(cls):
         # Each class level has a fresh list of supported child tags.
         cls._xml_tags = []
@@ -124,7 +127,7 @@ class AstNode:
 
     @classmethod
     def get_tag_names(cls) -> list[str]:
-        """Provide all known XMl tags that this code can parse."""
+        """Provide all known XML tags that this code can parse."""
         try:
             # Because a cached class property is hard to build
             return _KNOWN_TAG_NAMES[cls]
@@ -233,14 +236,14 @@ class TagRegistry:
     def node_from_xml(self, element: NSElement, allowed_types: tuple[type[A]] | None = None) -> A:
         """Find the ``AstNode`` subclass that corresponds to the given XML element,
         and initialize it with the element. This is a convenience shortcut.
-        ``"""
+        """
         node_class = self.resolve_class(element, allowed_types)
         return node_class.from_xml(element)
 
     def resolve_class(
         self, element: NSElement, allowed_types: tuple[type[A]] | None = None
     ) -> type[A]:
-        """Find the ``AstNode`` subclass that corresponds to the given XML element."""
+        """Find the :class:`AstNode` subclass that corresponds to the given XML element."""
         try:
             node_class = self.parsers[element.tag]
         except KeyError:

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/parsers/fes20/operators.py

@@ -227,7 +227,7 @@ class Operator(AstNode):
 
 @dataclass
 class IdOperator(Operator):
-    """List of :class:`~gisserver.parsers.fes20.identifers.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::

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/parsers/gml/geometries.py

@@ -89,7 +89,13 @@ 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)
+
+        # Using the WFS 2 format (urn:ogc:def:crs:EPSG::4326"), coordinates should be latitude/longitude.
+        # However, when providing legacy formats like srsName="EPSG:4326",
+        # input is assumed to be in legacy longitude/latitude axis ordering too.
+        # This reflects what GeoServer does: https://docs.geoserver.org/main/en/user/services/wfs/axis_order.html
+        if not srs.force_xy:
+            CRS.tag_geometry(geos_data, axis_order=AxisOrder.AUTHORITY)
         return cls(srs=srs, geos_data=geos_data)
 
     def __repr__(self):

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/parsers/wfs20/adhoc.py

@@ -48,7 +48,9 @@ class AdhocQuery(QueryExpression):
             <fes:SortBy>...</fes:SortBy>
         </wfs:Query>
 
-    And supports the KVP syntax::
+    And supports the KVP syntax:
+
+    .. code-block:: urlencoded
 
         ?SERVICE=WFS&...&TYPENAMES=ns:myType&FILTER=...&SORTBY=...&SRSNAME=...&PROPERTYNAME=...
         ?SERVICE=WFS&...&TYPENAMES=ns:myType&BBOX=...&SORTBY=...&SRSNAME=...&PROPERTYNAME=...

django_gisserver-2.1.1/gisserver/static/gisserver/index.css

@@ -0,0 +1,36 @@
+/* Common page styling */
+
+/*
+  This general CSS that can be disabled
+  by removing the .meta-page in the overwritten templates
+*/
+
+.meta-page {
+  margin: 2rem 2rem 4rem 2rem;
+}
+
+.meta-page h2 { margin: 2rem 0 0.5rem 0; }
+.meta-page h3 { margin: 1rem 0 0.5rem 0; }
+.meta-page p { margin: 0 0 1rem 0; }
+
+.meta-page code { color: #000; }
+
+.meta-page dl {
+  display: grid;
+  grid-gap: 2px 16px;
+  grid-template-columns: max-content;
+}
+.meta-page dd { grid-column-start: 2; margin: 0; }
+
+.meta-page .wfs-feature-type { margin-bottom: 2.5rem; }
+.meta-page .field-name { min-width: 20%; }
+.meta-page .field-type { min-width: 25%; }
+
+/* application-specific */
+p.connect-url { margin-left: 2.5rem; font-weight: bold; }
+
+tbody th { text-align: left; padding-right: 2rem; }
+tbody td { padding-right: 2rem; }
+.table > tbody > tr.complex-level-1 > th { padding-left: 20px; }
+.table > tbody > tr.complex-level-2 > th { padding-left: 40px; }
+.table > tbody > tr.complex-level-3 > th { padding-left: 60px; }

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/templates/gisserver/base.html

@@ -3,7 +3,10 @@
 <head>
   <meta http-equiv="content-type" content="text/html; charset=utf-8">
   <title>{% block title %}{{ service_description.title }} {{ accept_operations|dictsort:0|join:"/" }}{% endblock %}</title>
-  {% block link %}<link rel="stylesheet" type="text/css" href="{% static 'gisserver/index.css' %}">{% endblock %}
+  {% block link %}
+      <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.6/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-4Q6Gf2aSP4eDXB8Miphtr37CMZZQ5oXLH2yaXMJ2w8e2ZtHTl7GptT4jmndRuHDT" crossorigin="anonymous">
+      <link rel="stylesheet" type="text/css" href="{% static 'gisserver/index.css' %}">
+  {% endblock %}
   {% block extrahead %}{% endblock %}
 </head>
 <body class="{% block body-class %}meta-page{% endblock %}">

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/templates/gisserver/index.html

@@ -12,7 +12,7 @@
       {% if wfs_features %}
         <h2>{% translate "WFS Feature Types" %}</h2>
         {% for feature_type in wfs_features %}
-          <article>{% include "gisserver/wfs/feature_type.html" %}</article>
+          <article class="wfs-feature-type">{% include "gisserver/wfs/feature_type.html" %}</article>
         {% endfor %}
       {% endif %}
     {% endblock %}

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/templates/gisserver/service_description.html

@@ -18,5 +18,5 @@
 {% if connect_url %}
 <h2>{% translate "Using This WFS" %}</h2>
 <p>{% translate "Add the following URL to your GIS application:" %}</p>
-<p class="connect-url"><code>{{ connect_url }}</code></p>
+<p class="connect-url"><samp>{{ connect_url }}</samp></p>
 {% endif %}

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/templates/gisserver/wfs/feature_type.html

@@ -13,9 +13,13 @@
     <dt>{% translate "Supported CRS" %}:</dt>
     <dd>
       {% if GISSERVER_SUPPORTED_CRS_ONLY %}
-        {% blocktranslate with default_crs=feature_type.crs %}Any CRS value is supported, source data uses {{ default_crs }}.{% endblocktranslate %}
+        {% blocktranslate trimmed with default_crs=feature_type.crs supported_crs=feature_type.supported_crs|join:", " %}
+          {{ supported_crs }}, and all others. Source data uses {{ default_crs }}.
+        {% endblocktranslate %}
       {% else %}
-        {{ feature_type.supported_crs|join:", " }}
+        {% blocktranslate trimmed with default_crs=feature_type.crs supported_crs=feature_type.supported_crs|join:", " %}
+          {{ supported_crs }}. Source data uses {{ default_crs }}.
+        {% endblocktranslate %}
       {% endif %}
     </dd>
     {% if wfs_output_formats %}
@@ -35,6 +39,11 @@
 {% block fields %}
 <p>{% translate "The following fields are available:" %}</p>
 <table class="table table-striped">
+  <colgroup>
+    <col class="field-name" />
+    <col class="field-type" />
+    <col class="field-description" />
+  </colgroup>
   <thead><tr><th>{% translate "Field Name" %}</th><th>{% translate "Type" %}</th><th>{% translate "Description" %}</th></tr></thead>
   <tbody>
   {% for field in feature_type.fields %}

{django_gisserver-2.1 → django_gisserver-2.1.1}/gisserver/types.py

@@ -3,7 +3,7 @@
 These types are the internal schema definition, and the foundation for all output generation.
 
 The end-users of this library typically create a WFS feature type definition by using
-the :class:~gisserver.features.FeatureType` / :class:`~gisserver.features.FeatureField` classes.
+the :class:`~gisserver.features.FeatureType` / :class:`~gisserver.features.FeatureField` classes.
 
 The feature type classes use the model metadata to construct the internal XMLSchema structure.
 Nearly all WFS requests are handled by walking this structure (like ``DescribeFeatureType``
@@ -57,6 +57,7 @@ __all__ = [
     "GeometryXsdElement",
     "GmlIdAttribute",
     "GmlNameElement",
+    "GmlBoundedByElement",
     "ORMPath",
     "XPathMatch",
     "XsdAnyType",

{django_gisserver-2.1 → django_gisserver-2.1.1}/setup.py

@@ -31,6 +31,7 @@ tests_require = [
 docs_require = [
     "Django ~= 5.0",
     "sphinxcontrib-django >= 2.5",
+    "myst-parser >= 3.0.1",
     "psycopg2-binary >= 2.8.4",
 ]
 

django_gisserver-2.1/gisserver/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.1"  # follows PEP440

django_gisserver-2.1/gisserver/static/gisserver/index.css

@@ -1,20 +0,0 @@
-/* general CSS that can be disabled by removing the .meta-page in the overwritten templates */
-
-.meta-page {
-  font-family: Arial, sans-serif;
-  line-height: 1.5;
-  margin: 0 2rem 4rem 2rem;
-}
-
-.meta-page h2 { margin: 2rem 0 0.5rem 0; }
-.meta-page h3 { margin: 1rem 0 0.5rem 0; }
-.meta-page p { margin: 0 0 1rem 0; }
-
-/* application-specific */
-.connect-url { margin-left: 4rem; }
-
-tbody th { text-align: left; padding-right: 2rem; }
-tbody td { padding-right: 2rem; }
-.table > tbody > tr.complex-level-1 > th { padding-left: 20px; }
-.table > tbody > tr.complex-level-2 > th { padding-left: 40px; }
-.table > tbody > tr.complex-level-3 > th { padding-left: 60px; }