more edits

Author: timgraham

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

@@ -1,4 +1,4 @@
-name: Python Atlas Tests
+name: Python Tests on Atlas
 
 on:
   pull_request:

django_mongodb_backend/features.py

@@ -634,8 +634,9 @@ def supports_atlas_search(self):
             # An existing collection must be used on MongoDB 6, otherwise
             # the operation will not error when unsupported.
             self.connection.get_collection("django_migrations").list_search_indexes()
-        except OperationFailure:
-            # Error: $listSearchIndexes stage is only allowed on MongoDB Atlas
-            return False
+        except OperationFailure as exc:
+            if "$listSearchIndexes stage is only allowed on MongoDB Atlas" in str(exc):
+                return False
+            raise
         else:
             return True

django_mongodb_backend/indexes.py

@@ -109,6 +109,9 @@ class SearchIndex(Index):
     suffix = "six"
     _error_id_prefix = "django_mongodb_backend.indexes.SearchIndex"
 
+    def __init__(self, *, fields=(), name=None):
+        super().__init__(fields=fields, name=name)
+
     def check(self, model, connection):
         errors = []
         if not connection.features.supports_atlas_search:
@@ -161,10 +164,17 @@ def get_pymongo_index_model(
 class VectorSearchIndex(SearchIndex):
     suffix = "vsi"
     VALID_SIMILARITIES = frozenset(("euclidean", "cosine", "dotProduct"))
+    VALID_FIELD_TYPES = frozenset(("boolean", "date", "number", "objectId", "string", "uuid"))
     _error_id_prefix = "django_mongodb_backend.indexes.VectorSearchIndex"
 
-    def __init__(self, *expressions, fields=(), similarities="cosine", name=None, **kwargs):
-        super().__init__(*expressions, fields=fields, name=name, **kwargs)
+    def __init__(
+        self,
+        *,
+        fields=(),
+        similarities="cosine",
+        name=None,
+    ):
+        super().__init__(fields=fields, name=name)
         self.similarities = similarities
         self._multiple_similarities = isinstance(similarities, tuple | list)
         for func in similarities if self._multiple_similarities else (similarities,):
@@ -209,27 +219,24 @@ def check(self, model, connection):
                     )
             else:
                 search_type = self.search_index_data_types(field.db_type(connection))
-                # filter - for fields that contain boolean, date, objectId,
-                # numeric, string, or UUID values. Reference:
-                # https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-type/#atlas-vector-search-index-fields
-                if search_type not in {"number", "string", "boolean", "objectId", "uuid", "date"}:
+                # Validate allowed search types.
+                if search_type not in self.VALID_FIELD_TYPES:
                     errors.append(
                         Error(
-                            "VectorSearchIndex does not support "
-                            f"{field.get_internal_type()} '{field_name}'.",
+                            "VectorSearchIndex does not support field "
+                            f"'{field_name}' ({field.get_internal_type()}).",
                             obj=model,
                             id=f"{self._error_id_prefix}.E004",
+                            hint=f"Allowed types are {', '.join(sorted(self.VALID_FIELD_TYPES))}.",
                         )
                     )
         if self._multiple_similarities and expected_similarities != len(self.similarities):
-            similarity_function_text = (
-                "similarity" if expected_similarities == 1 else "similarities"
-            )
             errors.append(
                 Error(
-                    f"VectorSearchIndex requires the same number of similarities and "
-                    f"vector fields; expected {expected_similarities} "
-                    f"{similarity_function_text} but got {len(self.similarities)}.",
+                    f"VectorSearchIndex requires the same number of similarities "
+                    f"and vector fields; {model._meta.object_name} has "
+                    f"{expected_similarities} ArrayField(s) but similarities "
+                    f"has {len(self.similarities)} element(s).",
                     obj=model,
                     id=f"{self._error_id_prefix}.E005",
                 )

docs/source/ref/models/indexes.rst

@@ -18,6 +18,10 @@ Some MongoDB-specific indexes are available in
 Creates a basic :doc:`search index <atlas:atlas-search/index-definitions>` on
 the given field(s).
 
+Some fields such as :class:`~django.db.models.DecimalField` aren't
+supported. See the :ref:`Atlas documentation <atlas:bson-data-chart>` for a
+complete list of unsupported data types.
+
 If ``name`` isn't provided, one will be generated automatically. If you need
 to reference the name in your search query and don't provide your own name,
 you can lookup the generated one using ``Model._meta.indexes[0].name``
@@ -36,10 +40,10 @@ A subclass of :class:`SearchIndex` that creates a :doc:`vector search index
 
 Each index should references at least one vector field: an :class:`.ArrayField`
 with a :attr:`~.ArrayField.base_field` of :class:`~django.db.models.FloatField`
-or :class:`~django.db.models.DecimalField`.
+or :class:`~django.db.models.IntegerField`.
 
 It may also have other fields to filter on, provided the field stores
-``boolean``, ``date``, ``objectId``, ``numeric``, ``string``, or ``UUID``.
+``boolean``, ``date``, ``objectId``, ``numeric``, ``string``, or ``uuid``.
 
 Available values for ``similarities`` are ``"euclidean"``, ``"cosine"``, and
 ``"dotProduct"``. You can provide this value either a string, in which case

docs/source/releases/5.2.x.rst

@@ -12,3 +12,8 @@ Initial release from the state of :ref:`django-mongodb-backend 5.1.0 beta 2
 
 Regarding new features in Django 5.2,
 :class:`~django.db.models.CompositePrimaryKey` isn't supported.
+
+Other changes since Django MongoDB Backend 5.1.x:
+
+- Added support for :class:`.SearchIndex` and :class:`.VectorSearchIndex`.
+- The minimum supported version of ``pymongo`` is increased from 4.6 to 4.7.

tests/indexes_/models.py

@@ -15,13 +15,15 @@ class Data(EmbeddedModel):
 
 
 class SearchIndexTestModel(models.Model):
+    big_integer = models.BigIntegerField()
+    binary = models.BinaryField()
     boolean = models.BooleanField()
-    date = models.DateTimeField(auto_now=True)
-    embedded = EmbeddedModelField(Data)
+    char = models.CharField(max_length=100)
+    datetime = models.DateTimeField(auto_now=True)
+    embedded_model = EmbeddedModelField(Data)
     float = models.FloatField()
-    json_data = models.JSONField()
-    number = models.IntegerField()
+    integer = models.IntegerField()
+    json = models.JSONField()
     object_id = ObjectIdField()
-    text = models.CharField(max_length=100)
     vector_float = ArrayField(models.FloatField(), size=10)
     vector_integer = ArrayField(models.IntegerField(), size=10)

tests/indexes_/test_checks.py

@@ -117,9 +117,10 @@ class Meta:
             errors,
             [
                 checks.Error(
-                    "VectorSearchIndex does not support JSONField 'data'.",
+                    "VectorSearchIndex does not support field 'data' (JSONField).",
                     id="django_mongodb_backend.indexes.VectorSearchIndex.E004",
                     obj=Article,
+                    hint="Allowed types are boolean, date, number, objectId, string, uuid.",
                 )
             ],
         )
@@ -142,7 +143,8 @@ class Meta:
             [
                 checks.Error(
                     "VectorSearchIndex requires the same number of similarities "
-                    "and vector fields; expected 1 similarity but got 2.",
+                    "and vector fields; Article has 1 ArrayField(s) but similarities "
+                    "has 2 element(s).",
                     id="django_mongodb_backend.indexes.VectorSearchIndex.E005",
                     obj=Article,
                 ),
@@ -168,7 +170,8 @@ class Meta:
             [
                 checks.Error(
                     "VectorSearchIndex requires the same number of similarities "
-                    "and vector fields; expected 2 similarities but got 1.",
+                    "and vector fields; Article has 2 ArrayField(s) but similarities "
+                    "has 1 element(s).",
                     id="django_mongodb_backend.indexes.VectorSearchIndex.E005",
                     obj=Article,
                 ),

tests/indexes_/test_search_indexes.py

@@ -38,7 +38,33 @@ def test_vector_index_not_created(self):
         )
 
 
+class SearchIndexTests(SimpleTestCase):
+    def test_no_init_args(self):
+        """All arguments must be kwargs."""
+        msg = "SearchIndex.__init__() takes 1 positional argument but 2 were given"
+        with self.assertRaisesMessage(TypeError, msg):
+            SearchIndex("foo")
+
+    def test_no_extra_kargs(self):
+        """Unused wargs that appear on Index aren't accepted."""
+        msg = "SearchIndex.__init__() got an unexpected keyword argument 'condition'"
+        with self.assertRaisesMessage(TypeError, msg):
+            SearchIndex(condition="")
+
+
 class VectorSearchIndexTests(SimpleTestCase):
+    def test_no_init_args(self):
+        """All arguments must be kwargs."""
+        msg = "VectorSearchIndex.__init__() takes 1 positional argument but 2 were given"
+        with self.assertRaisesMessage(TypeError, msg):
+            VectorSearchIndex("foo")
+
+    def test_no_extra_kargs(self):
+        """Unused wargs that appear on Index aren't accepted."""
+        msg = "VectorSearchIndex.__init__() got an unexpected keyword argument 'condition'"
+        with self.assertRaisesMessage(TypeError, msg):
+            VectorSearchIndex(condition="")
+
     def test_deconstruct(self):
         index = VectorSearchIndex(name="recent_test_idx", fields=["number"])
         name, args, kwargs = index.deconstruct()
@@ -48,15 +74,15 @@ def test_deconstruct(self):
     def test_deconstruct_with_similarities(self):
         index = VectorSearchIndex(
             name="recent_test_idx",
-            fields=["number", "text"],
+            fields=["number", "char"],
             similarities=["cosine", "dotProduct"],
         )
         path, args, kwargs = index.deconstruct()
         self.assertEqual(
             kwargs,
             {
                 "name": "recent_test_idx",
-                "fields": ["number", "text"],
+                "fields": ["number", "char"],
                 "similarities": ["cosine", "dotProduct"],
             },
         )
@@ -87,23 +113,25 @@ class SearchIndexSchemaTests(SchemaAssertionMixin, TestCase):
     def test_simple(self):
         index = SearchIndex(
             name="recent_test_idx",
-            fields=["text"],
+            fields=["char"],
         )
         with connection.schema_editor() as editor:
             self.assertAddRemoveIndex(editor, index=index, model=SearchIndexTestModel)
 
-    def test_all_fields(self):
+    def test_valid_fields(self):
         index = SearchIndex(
             name="recent_test_idx",
             fields=[
+                "big_integer",
+                "binary",
+                "char",
                 "boolean",
-                "date",
-                "embedded",
+                "datetime",
+                "embedded_model",
                 "float",
-                "json_data",
-                "number",
+                "integer",
+                "json",
                 "object_id",
-                "text",
                 "vector_integer",
                 "vector_float",
             ],
@@ -118,29 +146,41 @@ def test_all_fields(self):
             expected_options = {
                 "dynamic": False,
                 "fields": {
+                    "big_integer": {
+                        "indexDoubles": True,
+                        "indexIntegers": True,
+                        "representation": "double",
+                        "type": "number",
+                    },
+                    "binary": {
+                        "indexOptions": "offsets",
+                        "norms": "include",
+                        "store": True,
+                        "type": "string",
+                    },
                     "boolean": {"type": "boolean"},
-                    "date": {"type": "date"},
-                    "embedded": {"dynamic": False, "fields": {}, "type": "embeddedDocuments"},
+                    "char": {
+                        "indexOptions": "offsets",
+                        "norms": "include",
+                        "store": True,
+                        "type": "string",
+                    },
+                    "datetime": {"type": "date"},
+                    "embedded_model": {"dynamic": False, "fields": {}, "type": "embeddedDocuments"},
                     "float": {
                         "indexDoubles": True,
                         "indexIntegers": True,
                         "representation": "double",
                         "type": "number",
                     },
-                    "json_data": {"dynamic": False, "fields": {}, "type": "document"},
-                    "number": {
+                    "integer": {
                         "indexDoubles": True,
                         "indexIntegers": True,
                         "representation": "double",
                         "type": "number",
                     },
+                    "json": {"dynamic": False, "fields": {}, "type": "document"},
                     "object_id": {"type": "objectId"},
-                    "text": {
-                        "indexOptions": "offsets",
-                        "norms": "include",
-                        "store": True,
-                        "type": "string",
-                    },
                     "vector_float": {"dynamic": False, "fields": {}, "type": "embeddedDocuments"},
                     "vector_integer": {"dynamic": False, "fields": {}, "type": "embeddedDocuments"},
                 },
@@ -155,22 +195,22 @@ def test_all_fields(self):
 @skipUnlessDBFeature("supports_atlas_search")
 class VectorSearchIndexSchemaTests(SchemaAssertionMixin, TestCase):
     def test_simple(self):
-        index = VectorSearchIndex(name="recent_test_idx", fields=["number"])
+        index = VectorSearchIndex(name="recent_test_idx", fields=["integer"])
         with connection.schema_editor() as editor:
             self.assertAddRemoveIndex(editor, index=index, model=SearchIndexTestModel)
 
     def test_multiple_fields(self):
         index = VectorSearchIndex(
             name="recent_test_idx",
             fields=[
-                "text",
+                "boolean",
+                "char",
+                "datetime",
+                "embedded_model",
+                "integer",
                 "object_id",
-                "number",
-                "embedded",
-                "vector_integer",
                 "vector_float",
-                "boolean",
-                "date",
+                "vector_integer",
             ],
         )
         with connection.schema_editor() as editor:
@@ -183,24 +223,24 @@ def test_multiple_fields(self):
             expected_options = {
                 "latestDefinition": {
                     "fields": [
-                        {"path": "text", "type": "filter"},
+                        {"path": "boolean", "type": "filter"},
+                        {"path": "char", "type": "filter"},
+                        {"path": "datetime", "type": "filter"},
+                        {"path": "embedded_model", "type": "filter"},
+                        {"path": "integer", "type": "filter"},
                         {"path": "object_id", "type": "filter"},
-                        {"path": "number", "type": "filter"},
-                        {"path": "embedded", "type": "filter"},
                         {
                             "numDimensions": 10,
-                            "path": "vector_integer",
+                            "path": "vector_float",
                             "similarity": "cosine",
                             "type": "vector",
                         },
                         {
                             "numDimensions": 10,
-                            "path": "vector_float",
+                            "path": "vector_integer",
                             "similarity": "cosine",
                             "type": "vector",
                         },
-                        {"path": "boolean", "type": "filter"},
-                        {"path": "date", "type": "filter"},
                     ]
                 },
                 "latestVersion": 0,