Add GeoDjango support

Author: timgraham

.github/workflows/runtests.py

@@ -3,6 +3,8 @@
 import pathlib
 import sys
 
+from django.core.exceptions import ImproperlyConfigured
+
 test_apps = [
     "admin_changelist",
     "admin_checks",
@@ -154,9 +156,20 @@
         [
             x.name
             for x in (pathlib.Path(__file__).parent.parent.parent.resolve() / "tests").iterdir()
+            # Omit GIS tests unless GIS libraries are installed.
+            if x.name != "gis_tests_"
         ]
     ),
 ]
+
+try:
+    from django.contrib.gis.db import models  # noqa: F401
+except ImproperlyConfigured:
+    # GIS libraries (GDAL/GEOS) not installed.
+    pass
+else:
+    test_apps.extend(["gis_tests", "gis_tests_"])
+
 runtests = pathlib.Path(__file__).parent.resolve() / "runtests.py"
 run_tests_cmd = f"python3 {runtests} %s --settings mongodb_settings -v 2"
 

.github/workflows/test-python-geo.yml

@@ -0,0 +1,60 @@
+# Identical to test-python.yml except that gdal-bin is also installed.
+name: Python Tests with GeoDjango
+
+on:
+  pull_request:
+      paths:
+      - '**.py'
+      - '!setup.py'
+      - '.github/workflows/test-python-geo.yml'
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash -eux {0}
+
+jobs:
+  build:
+    name: Django Test Suite
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout django-mongodb-backend
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: install django-mongodb-backend
+        run: |
+          pip3 install --upgrade pip
+          pip3 install -e .
+      - name: Checkout Django
+        uses: actions/checkout@v4
+        with:
+          repository: 'mongodb-forks/django'
+          ref: 'mongodb-5.2.x'
+          path: 'django_repo'
+          persist-credentials: false
+      - name: Install system packages for Django's Python test dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install gdal-bin libmemcached-dev
+      - name: Install Django and its Python test dependencies
+        run: |
+          cd django_repo/tests/
+          pip3 install -e ..
+          pip3 install -r requirements/py3.txt
+      - name: Copy the test settings file
+        run: cp .github/workflows/mongodb_settings.py django_repo/tests/
+      - name: Copy the test runner file
+        run: cp .github/workflows/runtests.py django_repo/tests/runtests_.py
+      - name: Start MongoDB
+        uses: supercharge/mongodb-github-action@90004df786821b6308fb02299e5835d0dae05d0d # 1.12.0
+        with:
+          mongodb-version: 6.0
+      - name: Run tests
+        run: python3 django_repo/tests/runtests_.py
+    permissions:
+        contents: read

django_mongodb_backend/features.py

@@ -1,9 +1,17 @@
+from django.core.exceptions import ImproperlyConfigured
 from django.db.backends.base.features import BaseDatabaseFeatures
 from django.utils.functional import cached_property
 from pymongo.errors import OperationFailure
 
+try:
+    from .gis.features import GISFeatures
+except ImproperlyConfigured:
+    # GIS libraries (GDAL/GEOS) not installed.
+    class GISFeatures:
+        pass
 
-class DatabaseFeatures(BaseDatabaseFeatures):
+
+class DatabaseFeatures(GISFeatures, BaseDatabaseFeatures):
     minimum_database_version = (6, 0)
     allow_sliced_subqueries_with_in = False
     allows_multiple_constraints_on_same_fields = False
@@ -105,7 +113,7 @@ def django_test_expected_failures(self):
             expected_failures.update(self._django_test_expected_failures_bitwise)
         return expected_failures
 
-    django_test_skips = {
+    _django_test_skips = {
         "Database defaults aren't supported by MongoDB.": {
             # bson.errors.InvalidDocument: cannot encode object:
             # <django.db.models.expressions.DatabaseDefault
@@ -569,6 +577,12 @@ def django_test_expected_failures(self):
         },
     }
 
+    @cached_property
+    def django_test_skips(self):
+        skips = super().django_test_skips
+        skips.update(self._django_test_skips)
+        return skips
+
     @cached_property
     def is_mongodb_6_3(self):
         return self.connection.get_database_version() >= (6, 3)

django_mongodb_backend/gis/__init__.py

@@ -0,0 +1,9 @@
+from django.core.exceptions import ImproperlyConfigured
+
+try:
+    from .lookups import register_lookups
+except ImproperlyConfigured:
+    # GIS libraries (GDAL/GEOS) not installed.
+    pass
+else:
+    register_lookups()

django_mongodb_backend/gis/adapter.py

@@ -0,0 +1,28 @@
+import collections
+
+
+class Adapter(collections.UserDict):
+    srid = 4326
+
+    def __init__(self, obj, geography=False):
+        """
+        Initialize on the spatial object per
+        https://www.mongodb.com/docs/manual/reference/geojson/.
+        """
+        if obj.__class__.__name__ == "GeometryCollection":
+            self.data = {
+                "type": obj.__class__.__name__,
+                "geometries": [self.get_data(x) for x in obj],
+            }
+        else:
+            self.data = self.get_data(obj)
+
+    def get_data(self, obj):
+        return {
+            "type": obj.__class__.__name__,
+            "coordinates": obj.coords,
+        }
+
+    @classmethod
+    def _fix_polygon(cls, poly):
+        return poly

django_mongodb_backend/gis/features.py

@@ -0,0 +1,64 @@
+from django.contrib.gis.db.backends.base.features import BaseSpatialFeatures
+from django.utils.functional import cached_property
+
+
+class GISFeatures(BaseSpatialFeatures):
+    has_spatialrefsys_table = False
+    supports_transform = False
+
+    @cached_property
+    def django_test_expected_failures(self):
+        expected_failures = super().django_test_expected_failures
+        expected_failures.update(
+            {
+                # annotate with Value not supported, e.g.
+                # QuerySet.annotate(p=Value(p, GeometryField(srid=4326)
+                "gis_tests.geoapp.test_expressions.GeoExpressionsTests.test_geometry_value_annotation",
+            }
+        )
+        return expected_failures
+
+    @cached_property
+    def django_test_skips(self):
+        skips = super().django_test_skips
+        skips.update(
+            {
+                "inspectdb not supported.": {
+                    "gis_tests.inspectapp.tests.InspectDbTests",
+                },
+                "Raw SQL not supported": {
+                    "gis_tests.geoapp.tests.GeoModelTest.test_raw_sql_query",
+                },
+                "MongoDB doesn't support the SRID used in this test.": {
+                    # Error messages:
+                    # - Can't extract geo keys
+                    # - Longitude/latitude is out of bounds
+                    "gis_tests.geoapp.test_expressions.GeoExpressionsTests.test_update_from_other_field",
+                    "gis_tests.layermap.tests.LayerMapTest.test_encoded_name",
+                    "gis_tests.relatedapp.tests.RelatedGeoModelTest.test06_f_expressions",
+                    # SouthTexasCity fixture objects use SRID 2278 which is ignored
+                    # by the patched version of loaddata in the Django fork.
+                    "gis_tests.distapp.tests.DistanceTest.test_init",
+                },
+                "ImproperlyConfigured isn't raised when using RasterField": {
+                    # Normally RasterField.db_type() raises an error, but MongoDB
+                    # migrations don't need to call it, so the check doesn't happen.
+                    "gis_tests.gis_migrations.test_operations.NoRasterSupportTests",
+                },
+                "MongoDB doesn't support redundant spatial indexes.": {
+                    # Error: Index already exists with a different name
+                    "gis_tests.geoapp.test_indexes.SchemaIndexesTests.test_index_name",
+                },
+                "GIS lookups not supported.": {
+                    "gis_tests.geoapp.tests.GeoModelTest.test_gis_query_as_string",
+                    "gis_tests.geoapp.tests.GeoLookupTest.test_gis_lookups_with_complex_expressions",
+                },
+                "GeoJSONSerializer doesn't support ObjectId.": {
+                    "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_fields_option",
+                    "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_geometry_field_option",
+                    "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_serialization_base",
+                    "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_srid_option",
+                },
+            },
+        )
+        return skips

django_mongodb_backend/gis/lookups.py

@@ -0,0 +1,10 @@
+from django.contrib.gis.db.models.lookups import GISLookup
+from django.db import NotSupportedError
+
+
+def gis_lookup(self, compiler, connection):  # noqa: ARG001
+    raise NotSupportedError(f"MongoDB does not support the {self.lookup_name} lookup.")
+
+
+def register_lookups():
+    GISLookup.as_mql = gis_lookup

django_mongodb_backend/gis/operations.py

@@ -0,0 +1,97 @@
+from django.contrib.gis import geos
+from django.contrib.gis.db import models
+from django.contrib.gis.db.backends.base.operations import BaseSpatialOperations
+
+from .adapter import Adapter
+
+
+class GISOperations(BaseSpatialOperations):
+    Adapter = Adapter
+
+    disallowed_aggregates = (
+        models.Collect,
+        models.Extent,
+        models.Extent3D,
+        models.MakeLine,
+        models.Union,
+    )
+
+    @property
+    def gis_operators(self):
+        return {}
+
+    unsupported_functions = {
+        "Area",
+        "AsGeoJSON",
+        "AsGML",
+        "AsKML",
+        "AsSVG",
+        "AsWKB",
+        "AsWKT",
+        "Azimuth",
+        "BoundingCircle",
+        "Centroid",
+        "ClosestPoint",
+        "Difference",
+        "Distance",
+        "Envelope",
+        "ForcePolygonCW",
+        "FromWKB",
+        "FromWKT",
+        "GeoHash",
+        "GeometryDistance",
+        "Intersection",
+        "IsEmpty",
+        "IsValid",
+        "Length",
+        "LineLocatePoint",
+        "MakeValid",
+        "MemSize",
+        "NumGeometries",
+        "NumPoints",
+        "Perimeter",
+        "PointOnSurface",
+        "Reverse",
+        "Scale",
+        "SnapToGrid",
+        "SymDifference",
+        "Transform",
+        "Translate",
+        "Union",
+    }
+
+    def geo_db_type(self, f):
+        return "object"
+
+    def get_geometry_converter(self, expression):
+        srid = expression.output_field.srid
+
+        def converter(value, expression, connection):  # noqa: ARG001
+            if value is None:
+                return None
+
+            geom_class = getattr(geos, value["type"])
+            if geom_class.__name__ == "GeometryCollection":
+                return geom_class(
+                    [
+                        getattr(geos, v["type"])(*v["coordinates"], srid=srid)
+                        for v in value["geometries"]
+                    ],
+                    srid=srid,
+                )
+            if issubclass(geom_class, geos.GeometryCollection):
+                sub_geom_class = geom_class._allowed
+                # MultiLineString allows both LineString and LinearRing but should be
+                # initialized with LineString.
+                if isinstance(sub_geom_class, tuple):
+                    sub_geom_class = sub_geom_class[0]
+                return geom_class(
+                    [
+                        sub_geom_class(*value["coordinates"][x])
+                        for x in range(len(value["coordinates"]))
+                    ],
+                    srid=srid,
+                )
+            return geom_class(*value["coordinates"], srid=srid)
+
+        return converter