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

{django_gisserver-2.0.dist-info → django_gisserver-2.1.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.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,24 @@ 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: myst-parser>=3.0.1; 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 +128,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 +157,7 @@ class PlacesWFSView(WFSView):
         FeatureType(
             Restaurant.objects.all(),
             fields="__all__",
-            other_crs=[RD_NEW]
+            other_crs=[RD_NEW, CRS84, WEB_MERCATOR]
         ),
     ]
 ```
@@ -176,5 +195,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.1.dist-info/RECORD

@@ -0,0 +1,68 @@
+django_gisserver-2.1.1.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+gisserver/__init__.py,sha256=UUQ8Wbk0ewAYeTqfEUnsJx6oCvEq_2LWeacF6xnZ-tI,40
+gisserver/compat.py,sha256=qmLeT7wGRIyA2ujUtVEuUX7qgr98snak9b5OTvnkhas,451
+gisserver/conf.py,sha256=Bb2hbLx1SM4la6-e8PrBQ7dg2z3Z1sopOlaTrfa6gbg,3666
+gisserver/crs.py,sha256=ChqLNZCHBCZmXphjJTT22jvhyMIwAAFtFSjwbH4Bigk,18330
+gisserver/db.py,sha256=p2bb6KMjFzsEEedFx4xZ1bBOFDd19MembXUKCnkk_pM,8154
+gisserver/exceptions.py,sha256=RhaRhY_DX_SzJuiXosyN9Mc0EnMkmz2frN0Cgxw9-Rk,10163
+gisserver/features.py,sha256=njVzctaKBiGsuSz8ATO_4GlNsXiEM-kJcH0y2yjMFco,36445
+gisserver/geometries.py,sha256=sXHr7LR4PgKImCVbENBxMBxAnz3AB8-TZWunIIGrAs0,3739
+gisserver/projection.py,sha256=yja8baq8sWblhytrD0yPlTH-v5z6pIy6mzUu1sLc2eQ,15301
+gisserver/types.py,sha256=XD63wq7iA3cHpdZ1r2MoxNK-sohGj5IoBCwoaA4xNzk,43939
+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=RrQp7iiMYtYf-PAcYLqO53b53GYBD3_CoTtZQIqbhyQ,35174
+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=zFb64uaIgAT9THV07l0pnuzWfXkzJ2CwT1z6lVGwrag,15688
+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=IQ-ArgRtmk9FRaBP901DqzlC2NKfQhoTv_VcgxGDs4Q,33608
+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=DbQTYGDLMw0JRwdNrSR7ia2vIAfS5AHz6lBOFvrfLc0,6120
+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=O33rT5WEheEpJV-EOtsPf-U7PR0TmaR-MWxrTyFvQwY,9459
+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=Luh9Ajc9C-9Q1QkwZcXI2NtRMRjiXxcRAXVn7PCGblo,994
+gisserver/templates/gisserver/base.html,sha256=3wNNs8FwsG0FXJmEE0ad8W9nFfYiTIjipeD23X1QBY8,817
+gisserver/templates/gisserver/index.html,sha256=fpijm56m7WzEynNHWMWmuDXXgqJLGWodgW-JNFlu-ts,664
+gisserver/templates/gisserver/service_description.html,sha256=PbJk-V3u-NhjSDnwSdgzlud5U4WhRbCRWu-8EUACibg,1086
+gisserver/templates/gisserver/wfs/feature_field.html,sha256=TmUNCme7E2vxofVVhiysD1A0ZTXhtDzd78ogGn9Y9lc,613
+gisserver/templates/gisserver/wfs/feature_type.html,sha256=Kl_0c7nnlc7Z1bzJOq8v7fCbU7DLuWC3uJWrde1-_4Y,2395
+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.1.dist-info/METADATA,sha256=SrC9CXZWeRJXbNIKEZzf2DlJHY_gtPnhmCD9NWn8eqo,6851
+django_gisserver-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+django_gisserver-2.1.1.dist-info/top_level.txt,sha256=8zFCEMmkpixE4TPiOAlxSq3PD2EXvAeFKwG4yZoIIOQ,10
+django_gisserver-2.1.1.dist-info/RECORD,,

{django_gisserver-2.0.dist-info → django_gisserver-2.1.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.1"  # follows PEP440

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

gisserver/crs.py

@@ -0,0 +1,452 @@
+"""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 import conf
+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_STR = {}
+_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, eq=False)
+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)
+
+    #: Tell whether the input format used the legacy notation.
+    force_xy: bool = False
+
+    @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 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_prefix(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
+
+        return cls(
+            domain="ogc",
+            authority="EPSG",
+            version="",
+            crsid=str(srid),
+            srid=int(srid),
+        )
+
+    @classmethod
+    def _from_urn(cls, urn):  # noqa: C901
+        """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}")
+
+        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) or "",
+            crsid=crsid,
+            srid=srid,
+        )
+        crs.__dict__["origin"] = urn
+        return crs
+
+    @classmethod
+    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 origin.startswith(prefix):
+                crsid = origin[len(prefix) :]
+                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,
+                    force_xy=force_xy,
+                )
+                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:`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):
+        """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.legacy if self.force_xy else self.urn
+
+    def __eq__(self, other):
+        if isinstance(other, CRS):
+            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))
+
+    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 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)
+
+            # 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()
+            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)
+
+    def apply_to(
+        self,
+        geometry: AnyGeometry,
+        clone=False,
+        axis_order: AxisOrder | None = None,
+    ) -> 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``.
+
+        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.
+
+        :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 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)
+        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" and self.srid != 4326:
+            # Only register for EPSG to avoid conflicting axis ordering issues.
+            # (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_STR[str(self)] = 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()