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

{django_gisserver-2.0.dist-info → django_gisserver-2.1.dist-info}/METADATA

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: django-gisserver
-Version: 2.0
+Version: 2.1
 Summary: Django speaking WFS 2.0 (exposing GeoDjango model fields)
 Home-page: https://github.com/amsterdam/django-gisserver
 Author: Diederik van der Boor
 Author-email: opensource@edoburu.nl
 License: Mozilla Public License 2.0
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
@@ -33,9 +32,10 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Django>=3.2
-Requires-Dist: defusedxml>=0.6.0
-Requires-Dist: lru-dict>=1.1.7
+Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: lru_dict>=1.1.7
 Requires-Dist: orjson>=3.9.15
+Requires-Dist: pyproj>=3.6.1
 Provides-Extra: tests
 Requires-Dist: django-environ>=0.4.5; extra == "tests"
 Requires-Dist: psycopg2-binary>=2.8.4; extra == "tests"
@@ -43,6 +43,23 @@ Requires-Dist: lxml>=4.9.1; extra == "tests"
 Requires-Dist: pytest>=6.2.3; extra == "tests"
 Requires-Dist: pytest-django>=4.1.0; extra == "tests"
 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: psycopg2-binary>=2.8.4; extra == "docs"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![Documentation](https://readthedocs.org/projects/django-gisserver/badge/?version=latest)](https://django-gisserver.readthedocs.io/en/latest/?badge=latest)
 [![Actions](https://github.com/Amsterdam/django-gisserver/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/Amsterdam/django-gisserver/actions/workflows/tests.yaml)
@@ -110,12 +127,13 @@ class Restaurant(models.Model):
 Write a view that exposes this model as a WFS feature:
 
 ```python
+from gisserver.crs import CRS, CRS84, WEB_MERCATOR
 from gisserver.features import FeatureType, ServiceDescription
-from gisserver.geometries import CRS, WGS84
 from gisserver.views import WFSView
 from .models import Restaurant
 
-RD_NEW = CRS.from_srid(28992)
+# As example, the local coordinate system for The Netherlands
+RD_NEW = CRS.from_string("urn:ogc:def:crs:EPSG::28992")
 
 
 class PlacesWFSView(WFSView):
@@ -138,7 +156,7 @@ class PlacesWFSView(WFSView):
         FeatureType(
             Restaurant.objects.all(),
             fields="__all__",
-            other_crs=[RD_NEW]
+            other_crs=[RD_NEW, CRS84, WEB_MERCATOR]
         ),
     ]
 ```
@@ -176,5 +194,3 @@ software developed with public money is also publicly available.
 
 This package is initially developed by the City of Amsterdam, but the tools
 and concepts created in this project can be used in any city.
-
-

django_gisserver-2.1.dist-info/RECORD

@@ -0,0 +1,68 @@
+django_gisserver-2.1.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+gisserver/__init__.py,sha256=EZRBJR6U2egJTZDzOVWUz5AOLuAcwyxzkLAMaShy2TA,38
+gisserver/compat.py,sha256=qmLeT7wGRIyA2ujUtVEuUX7qgr98snak9b5OTvnkhas,451
+gisserver/conf.py,sha256=ppoyVS95mMoQXVbPxPar-tkq1t7fE0J3F6IyKitMWuA,2563
+gisserver/crs.py,sha256=Bll3N9FrEG0jqEFDq5bzxwKHk1PrX8DDUqHJBcsgnZw,15648
+gisserver/db.py,sha256=NI__Kjp_W2Pfip0HL33so4QckTP8AFAlL0Ss1xehhf4,8026
+gisserver/exceptions.py,sha256=RhaRhY_DX_SzJuiXosyN9Mc0EnMkmz2frN0Cgxw9-Rk,10163
+gisserver/features.py,sha256=2EONhGuOteY1Fb_RLnFXo80aZ8-SOlA8YGrZepPh-DE,36200
+gisserver/geometries.py,sha256=-Jl02yKo7KXJO5AgW93453P2qLfA3kYJKgvPSonsbTU,3738
+gisserver/projection.py,sha256=yja8baq8sWblhytrD0yPlTH-v5z6pIy6mzUu1sLc2eQ,15301
+gisserver/types.py,sha256=Dwxs7c8jclRK9HhXub9Syv8MM1OVmfez1XP464jGuv4,43911
+gisserver/views.py,sha256=vTB0-BuNKoqPKjKIwNe8xtm_erM_yD8tmkw25vppoj4,20312
+gisserver/extensions/__init__.py,sha256=MsYUsNsoxxjeDHhx4DW9eGXvmOnI5PkoUXvKxRZaRRw,136
+gisserver/extensions/functions.py,sha256=enEarl4TUfGVA0QWlURU-QZjTaLbIEjOGjNzjF7z8jI,11629
+gisserver/extensions/queries.py,sha256=uqiuUnHi2YiFhFA7cBsaBg9MyFOU-v9Gdp0tHJ1wE_k,9653
+gisserver/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/management/commands/loadgeojson.py,sha256=lmvxXFEVGOWRELLB3u7M3hiJg2TQEICJOatdHLw8toI,12130
+gisserver/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/operations/base.py,sha256=SP3PV78bIFCeCQxEFMqIhj0YBjn1g6UqhyoK_Ub4ZxU,10113
+gisserver/operations/wfs20.py,sha256=r_2dcqzN5xw2LIOVE7Ofe93t9GvNx7ESFWKRnnW10Y4,20964
+gisserver/output/__init__.py,sha256=1-bzgNq1yGuWGse2zLXUwTnR7-FpfosGCzDm97diKRM,1133
+gisserver/output/base.py,sha256=igcOhjJkziPlpPJjwfyyC0S1LHfRI8Em-UMNnX5Lk-E,11247
+gisserver/output/csv.py,sha256=1Bz3o3-dvdEFWWLrDj-cxCp7My6IMMakmwAZIfPsjc4,6906
+gisserver/output/geojson.py,sha256=0Mm_fqi-v1MzxWJ3tDL1OrJpcteZ9nQBgilqQ_nG7V4,11633
+gisserver/output/gml32.py,sha256=GNqmEx-GPgT4EvykDEauMZL5AcQcq4rahIAY6Bm9lLo,33266
+gisserver/output/iters.py,sha256=YbvtIIy977Snm5m7cYyQext0GCpo8S_u4azTCBNqqgw,8355
+gisserver/output/results.py,sha256=_RNm7IVBC5j5CQY2q65MAWCdVSfRSexas7f8KtPGN9g,14668
+gisserver/output/stored.py,sha256=m3JcR4MUilyuM_5J6XJDOIyzrhRJbcpg-6FMKy69csc,5763
+gisserver/output/utils.py,sha256=dA4Y-6ZUBjjCC8ueO5AcYaVebB5M6ynXUtrw7yyOcoQ,3001
+gisserver/output/xmlschema.py,sha256=fHj8h9-vG508uRmM-kD5r2omde2wa_myJWWwcWe2lus,6445
+gisserver/parsers/__init__.py,sha256=eGORBeT0F8fR3AadV1uq8dbCeZtIeK0-__CcXwSvXgs,402
+gisserver/parsers/ast.py,sha256=3ereccG1m_PWNJXP_IdUKiX0I_zLpnIghubb0-p6sas,15499
+gisserver/parsers/query.py,sha256=IbsWBSAlOKDgz8BS-JirxVCqzQxSpYqIxGEhv0-sOVc,6695
+gisserver/parsers/values.py,sha256=QCnHBlMAGDefoC51ujOrQc1YEb3RYYP7aq5UIDweJO0,4166
+gisserver/parsers/xml.py,sha256=uys1ddpx4BEDFg1WmknfATl4vJpgpKbb0yV2QT2kJqs,9753
+gisserver/parsers/fes20/__init__.py,sha256=P24auC3LN_DEnF6bK0er52F8I2_oLS26gBCJOMcpNT4,2423
+gisserver/parsers/fes20/expressions.py,sha256=Yw1RvotstgTIlW49_Vfa4b1iODFl8Nd34RKpPLuJjTw,14015
+gisserver/parsers/fes20/filters.py,sha256=ssS-XhnUoWayPrAx1ZNQj7RlTAu-eS47pB_a0zeWjCQ,6677
+gisserver/parsers/fes20/identifiers.py,sha256=Y1diAHHVYWBWNy4wPakXdx9DPloX-jphdbmD8DTuhhU,4107
+gisserver/parsers/fes20/lookups.py,sha256=rrWGM5s3qx-yMbz7ogg8BTxzcmQdHfqqJ_9jF7BObrg,5430
+gisserver/parsers/fes20/operators.py,sha256=szkIXIdvKKwNqCTOjyO_KKvpgsxHHPjMppEqWdWmzz4,33609
+gisserver/parsers/fes20/sorting.py,sha256=RRCepyXCxD9zt8a0fu5oneV8Ta8A0-bOU5aou4v8nQE,5034
+gisserver/parsers/gml/__init__.py,sha256=T7_kSRnPTGvwoOXpcPgGeRTjO5zUxbvifkkUHUK_pLI,1484
+gisserver/parsers/gml/base.py,sha256=uBg9BRBZYAmXrfhQuhs-cVZKJqs8Ksh61CPezPN2-cU,1636
+gisserver/parsers/gml/geometries.py,sha256=oC8RltuylrivZSdMBMlvB_tjgWHEB6Jm_WICHRlwV1o,5710
+gisserver/parsers/ows/__init__.py,sha256=0SeM6vfwjWI-WeRD7eS_iN4Jsl8uzXr2yMFpZVHokb4,624
+gisserver/parsers/ows/kvp.py,sha256=1NDXcaO1Z3TRxZ4F11xoNnsutq12oEyYoJv7SMX1IPE,7235
+gisserver/parsers/ows/requests.py,sha256=ob66EWEJBEbjgGoPhk8qBE0BuDn2sYPsjr4Z_elvqss,5540
+gisserver/parsers/wfs20/__init__.py,sha256=t66iqcImqerH3Z1tMiWCms3WLmJXybUDqhcEXvITaWU,924
+gisserver/parsers/wfs20/adhoc.py,sha256=C6uBzxs90S2Z2Cr_sNP6u7x0QMIc_jz_Zcf76asqjFA,9428
+gisserver/parsers/wfs20/base.py,sha256=nPXwyQryjEdwoBq78a6KLHv5wzqdDbkeW4kfmOHXvIM,5867
+gisserver/parsers/wfs20/projection.py,sha256=irGQrVyOj5q9Or1rw99A3nn3on6PlGeB4261XUx6AkE,3932
+gisserver/parsers/wfs20/requests.py,sha256=Oi4HxiMs9_ij7CEOFmyu4GeN6VKyc9lJBkvIG5zrrSM,16853
+gisserver/parsers/wfs20/stored.py,sha256=ptTYGxfVkwlNtn6uF1my_2fSTpM9KWdtzEZPyKWpTyk,7195
+gisserver/static/gisserver/index.css,sha256=pfIpi-aZalg_181S4ac34J2BhsIy7yz00-jTgDfWNog,663
+gisserver/templates/gisserver/base.html,sha256=7HdLTW9-XwLrUL2TJsuHATMRNELYFBmLYFMQG80V9Xk,590
+gisserver/templates/gisserver/index.html,sha256=_n7YSBLVZg9SGDnFmvTMTTn8psAFTiIUvCjFM7Cthuc,639
+gisserver/templates/gisserver/service_description.html,sha256=E74PcikUA2vSSUJvsa8iZtGX7OpKU4i4IHINjHhibDw,1086
+gisserver/templates/gisserver/wfs/feature_field.html,sha256=TmUNCme7E2vxofVVhiysD1A0ZTXhtDzd78ogGn9Y9lc,613
+gisserver/templates/gisserver/wfs/feature_type.html,sha256=RDWwlAhrVPa-_J9Ys_AthaEXNxZ0Sqrx0Z2evHBUP64,2010
+gisserver/templates/gisserver/wfs/2.0.0/get_capabilities.xml,sha256=SGZSn7cDU_Oai6d45xrkqhax5CPyI1oIc8BZLOEw1X4,8695
+gisserver/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gisserver/templatetags/gisserver_tags.py,sha256=L2YG-PxiKR0QWBMRLLrL_VR94p6wCb5HzgnrPMg4hug,995
+django_gisserver-2.1.dist-info/METADATA,sha256=V-cCFscSUoeVvL69Q1L-iNNOzYNfuCmNciOA7X8MdVQ,6798
+django_gisserver-2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+django_gisserver-2.1.dist-info/top_level.txt,sha256=8zFCEMmkpixE4TPiOAlxSq3PD2EXvAeFKwG4yZoIIOQ,10
+django_gisserver-2.1.dist-info/RECORD,,

{django_gisserver-2.0.dist-info → django_gisserver-2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gisserver/__init__.py

@@ -1 +1 @@
-__version__ = "2.0"  # follows PEP440
+__version__ = "2.1"  # follows PEP440

gisserver/crs.py

@@ -0,0 +1,401 @@
+"""Helper classes for Coordinate Reference System translations.
+
+This includes the CRS parsing, coordinate transforms and axis orientation.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import typing
+from dataclasses import dataclass, field
+from functools import cached_property, lru_cache
+
+import pyproj
+from django.contrib.gis.gdal import AxisOrder, CoordTransform, OGRGeometry, SpatialReference
+from django.contrib.gis.geos import GEOSGeometry
+
+from gisserver.exceptions import ExternalValueError
+
+CRS_URN_REGEX = re.compile(
+    r"^urn:(?P<domain>[a-z]+)"
+    r":def:crs:(?P<authority>[a-z]+)"
+    r":(?P<version>[0-9]+(\.[0-9]+(\.[0-9]+)?)?)?"
+    r":(?P<id>[0-9]+|crs84)"
+    r"$",
+    re.IGNORECASE,
+)
+
+AnyGeometry = typing.TypeVar("AnyGeometry", GEOSGeometry, OGRGeometry)
+
+__all__ = [
+    "CRS",
+    "CRS84",
+    "WEB_MERCATOR",
+    "WGS84",
+]
+
+# Caches to avoid reinitializing WGS84 each time.
+_COMMON_CRS_BY_URN = {}
+_COMMON_CRS_BY_SRID = {}
+
+
+logger = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=200)  # Using lru-cache to avoid repeated GDAL c-object construction
+def _get_spatial_reference(srs_input: str | int, srs_type, axis_order):
+    """Construct an GDAL object reference"""
+    logger.debug(
+        "Constructed GDAL SpatialReference(%r, srs_type=%r, axis_order=%s)",
+        srs_input,
+        srs_type,
+        axis_order,
+    )
+    return SpatialReference(srs_input, srs_type=srs_type, axis_order=axis_order)
+
+
+@lru_cache(maxsize=100)
+def _get_coord_transform(source: SpatialReference, target: SpatialReference) -> CoordTransform:
+    """Get an efficient coordinate transformation object.
+
+    The CoordTransform should be used when performing the same
+    coordinate transformation repeatedly on different geometries.
+
+    Using a CoordinateTransform also allows setting the AxisOrder setting
+    on both ends. When calling ``GEOSGeometry.transform()``, Django will
+    create an internal CoordTransform object internally without setting AxisOrder,
+    implicitly setting its source SpatialReference to be 'AxisOrder.TRADITIONAL'.
+    """
+    return CoordTransform(source, target)
+
+
+_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)
+class CRS:
+    """
+    Represents a CRS (Coordinate Reference System), which preferably follows the URN format
+    as specified by `the OGC consortium <http://www.opengeospatial.org/ogcUrnPolicy>`_.
+    """
+
+    # CRS logic, based upon https://github.com/wglas85/django-wfs/blob/master/wfs/helpers.py
+    # Copyright (c) 2006 Wolfgang Glas - Apache 2.0 licensed
+    # Ported to Python 3.6 style.
+
+    #: Either "ogc" or "opengis", whereas "ogc" is highly recommended.
+    domain: str
+
+    #: Either "OGC" or "EPSG".
+    authority: str
+
+    #: The version of the authorities' SRS registry, which is empty or
+    #: contains two or three numeric components separated by dots like "6.9" or "6.11.9".
+    #: For WFS 2.0 this is typically empty.
+    version: str
+
+    #: A string representation of the coordinate system reference ID.
+    #: For OGC, only "CRS84" is supported as crsid. For EPSG, this is the formatted CRSID.
+    crsid: str
+
+    #: The integer representing the numeric spatial reference ID as
+    #: used by the EPSG and GIS database backends.
+    srid: int
+
+    #: GDAL SpatialReference with PROJ.4 / WKT content to describe the exact transformation.
+    backends: tuple[SpatialReference, SpatialReference] = (None, None)
+
+    #: Original input
+    origin: str = field(init=False, default=None)
+
+    @classmethod
+    def from_string(cls, uri: str | int) -> CRS:
+        """
+        Parse an CRS (Coordinate Reference System) URI, which preferably follows the URN format
+        as specified by `the OGC consortium <http://www.opengeospatial.org/ogcUrnPolicy>`_
+        and construct a new CRS instance.
+
+        The value can be 3 things:
+
+        * A URI in OGC URN format.
+        * A legacy CRS URI ("epsg:<SRID>", or "http://www.opengis.net/...").
+        * A numeric SRID (which calls :meth:`from_srid()`)
+        """
+        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)
+
+    @classmethod
+    def from_srid(cls, srid: int):
+        """Instantiate this class using a numeric spatial reference ID
+
+        This is logically identical to calling::
+
+            CRS.from_string("urn:ogc:def:crs:EPSG::<SRID>")
+        """
+        if common_crs := _COMMON_CRS_BY_SRID.get(srid):
+            return common_crs  # Avoid object re-creation
+
+        crs = 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
+
+        urn_match = CRS_URN_REGEX.match(urn)
+        if not urn_match:
+            raise ExternalValueError(f"Unknown CRS URN [{urn}] specified: {CRS_URN_REGEX.pattern}")
+
+        domain = urn_match.group("domain")
+        authority = urn_match.group("authority").upper()
+
+        if domain not in ("ogc", "opengis"):
+            raise ExternalValueError(f"CRS URI [{urn}] contains unknown domain [{domain}]")
+
+        if authority == "EPSG":
+            crsid = urn_match.group("id")
+            try:
+                srid = int(crsid)
+            except ValueError:
+                raise ExternalValueError(
+                    f"CRS URI [{urn}] should contain a numeric SRID value."
+                ) from None
+        elif authority == "OGC":
+            # urn:ogc:def:crs:OGC::CRS84 has x/y ordering (longitude/latitude)
+            crsid = urn_match.group("id").upper()
+            if crsid not in ("CRS84", "84"):
+                raise ExternalValueError(f"OGC CRS URI from [{urn}] contains unknown id [{id}]")
+            srid = 4326
+        else:
+            raise ExternalValueError(f"CRS URI [{urn}] contains unknown authority [{authority}]")
+
+        crs = cls(
+            domain=domain,
+            authority=authority,
+            version=urn_match.group(3),
+            crsid=crsid,
+            srid=srid,
+        )
+        crs.__dict__["origin"] = urn
+        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#",
+        ):
+            if luri.startswith(head):
+                crsid = luri[len(head) :]
+                try:
+                    srid = int(crsid)
+                except ValueError:
+                    raise ExternalValueError(
+                        f"CRS URI [{uri}] should contain a numeric SRID value."
+                    ) from None
+
+                crs = cls(
+                    domain="ogc",
+                    authority="EPSG",
+                    version="",
+                    crsid=crsid,
+                    srid=srid,
+                )
+                crs.__dict__["origin"] = uri
+                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}"
+
+    @cached_property
+    def urn(self):
+        """Return The OGC URN corresponding to this CRS."""
+        return f"urn:{self.domain}:def:crs:{self.authority}:{self.version or ''}:{self.crsid}"
+
+    @property
+    def is_north_east_order(self) -> bool:
+        """Tell whether the axis is in north/east ordering."""
+        return self.axis_direction == ["north", "east"]
+
+    @cached_property
+    def axis_direction(self) -> list[str]:
+        """Tell what the axis ordering of this coordinate system is.
+
+        For example, WGS84 will return ``['north', 'east']``.
+
+        While computer systems typically use X,Y, other systems may use northing/easting.
+        Historically, latitude was easier to measure and given first.
+        In physics, using 'radial, polar, azimuthal' is again a different perspective.
+        See: https://wiki.osgeo.org/wiki/Axis_Order_Confusion for a good summary.
+        """
+        proj_crs = self._as_proj()
+        return [axis.direction for axis in proj_crs.axis_info]
+
+    def __str__(self):
+        return 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
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        """Used to match objects in a set."""
+        return hash((self.authority, self.srid))
+
+    def _as_gdal(self, axis_order: AxisOrder) -> SpatialReference:
+        """Generate the GDAL Spatial Reference object."""
+        if self.backends[axis_order] is None:
+            backends = list(self.backends)
+            if self.origin:
+                backends[axis_order] = _get_spatial_reference(self.origin, "user", axis_order)
+            else:
+                backends[axis_order] = _get_spatial_reference(self.srid, "epsg", axis_order)
+
+            # Write back in "readonly" format.
+            self.__dict__["backends"] = tuple(backends)
+
+        return self.backends[axis_order]
+
+    def _as_proj(self) -> pyproj.CRS:
+        """Generate the PROJ CRS object"""
+        if isinstance(self.origin, str) and not self.origin.isdigit():
+            return _get_proj_crs_from_string(self.origin)
+        else:
+            return _get_proj_crs_from_authority(self.authority, self.srid)
+
+    def apply_to(
+        self,
+        geometry: AnyGeometry,
+        clone=False,
+        axis_order: AxisOrder = AxisOrder.AUTHORITY,
+    ) -> AnyGeometry | None:
+        """Transform the geometry using this coordinate reference.
+
+        Every transformation within this package happens through this method,
+        giving full control over coordinate transformations.
+
+        A bit of background: geometries are provided as ``GEOSGeometry`` from the database.
+        This is basically a simple C-based storage implementing "OpenGIS Simple Features for SQL",
+        except it does *not* store axis orientation. These are assumed to be x/y.
+
+        To perform transformations, GeoDjango loads the GEOS-geometry into GDAL/OGR.
+        The transformed geometry is loaded back to GEOS. To avoid this conversion,
+        pass the OGR object directly and continue working on that.
+
+        Internally, this method caches the used GDAL ``CoordTransform`` object,
+        so repeated transformations of the same coordinate systems are faster.
+
+        The axis order can change during the transformation.
+        From a programming perspective, screen coordinates (x/y) were traditionally used.
+        However, various systems and industries have always worked with north/east (y/x).
+        This includes systems with critical safety requirements in aviation and maritime.
+        The CRS authority reflects this practice. What you need depends on the use case:
+
+        * The (GML) output of WFS 2.0 and WMS 1.3 respect the axis ordering of the CRS.
+        * GeoJSON always provides coordinates in x/y, to keep web-based clients simple.
+        * PostGIS stores the data in x/y.
+        * WFS 1.0 used x/y, WFS 1.3 used y/x except for ``EPSG:4326``.
+
+        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.
+
+        :param geometry: The GEOS Geometry, or GDAL/OGR loaded geometry.
+        :param clone: Whether the object is changed in-place, or a copy is returned.
+                      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 isinstance(geometry, OGRGeometry):
+            transform = _get_coord_transform(geometry.srs, self._as_gdal(axis_order=axis_order))
+            return geometry.transform(transform, clone=clone)
+        else:
+            # See if the geometry was tagged with a CRS.
+            # When the data comes from an unknown source, assume this is from database storage.
+            # PostGIS stores data in longitude/latitude (x/y) ordering, even for srid 4326.
+            # By passing the 'AxisOrder.TRADITIONAL', a conversion from 4326 to 4326
+            # with 'AxisOrder.AUTHORITY' will detect that coordinate ordering needs to be changed.
+            source_axis_order = getattr(geometry, "_axis_order", AxisOrder.TRADITIONAL)
+
+            if self.srid == geometry.srid and source_axis_order == axis_order:
+                # Avoid changes if spatial reference system is identical, and no axis need to change.
+                if clone:
+                    return geometry.clone()
+                else:
+                    return None
+
+            # Get GDAL spatial reference for converting coordinates (uses proj internally).
+            # Using a cached coordinate transform object (is faster for repeated transforms)
+            # The object is also tagged so another apply_to() call would recognize the state.
+            source = _get_spatial_reference(geometry.srid, "epsg", source_axis_order)
+            target = self._as_gdal(axis_order=axis_order)
+            transform = _get_coord_transform(source, target)
+
+            # Transform
+            geometry = geometry.transform(transform, clone=clone)
+            if clone:
+                self.tag_geometry(geometry, axis_order=axis_order)
+            return geometry
+
+    @classmethod
+    def tag_geometry(self, geometry: GEOSGeometry, axis_order: AxisOrder):
+        """Associate this object with the geometry.
+
+        This informs the :meth:`apply_to` method that this source geometry
+        already had the correct axis ordering (e.g. it was part of the ``<fes:BBOX>`` logic).
+        The srid integer doesn't communicate that information.
+        """
+        geometry._axis_order = axis_order
+
+    def cache_instance(self):
+        """Cache a common CRS, no need to re-instantiate the same object again.
+        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":
+            # Only register for EPSG to avoid conflicting axis ordering issues.
+            # (WGS84 and CRS84 both use srid 4326)
+            _COMMON_CRS_BY_SRID[self.srid] = self
+
+        _COMMON_CRS_BY_URN[self.urn] = self
+
+
+#: Worldwide GPS, latitude/longitude (y/x). https://epsg.io/4326
+WGS84 = CRS.from_string("urn:ogc:def:crs:EPSG::4326")
+
+#: GeoJSON default. This is like WGS84 but with longitude/latitude (x/y).
+CRS84 = CRS.from_string("urn:ogc:def:crs:OGC::CRS84")
+
+#: Spherical Mercator (Google Maps, Bing Maps, OpenStreetMap, ...), see https://epsg.io/3857
+WEB_MERCATOR = CRS.from_string("urn:ogc:def:crs:EPSG::3857")
+
+
+# Register these common ones:
+WGS84.cache_instance()
+CRS84.cache_instance()
+WEB_MERCATOR.cache_instance()