WIP

Author: NoahStapp

mongoengine/base/datastructures.py

@@ -472,3 +472,60 @@ def __getattr__(self, name):
 
     def __repr__(self):
         return f"<LazyReference({self.document_type}, {self.pk!r})>"
+
+
+class RawDict:
+    def __init__(self, data, deserialize_method):
+        self._data = data
+        self.deserialize_method = deserialize_method
+
+    def deserialize(self):
+        return self.deserialize_method(self._data)
+
+    def __setitem__(self, key, item):
+        self._data[key] = item
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __repr__(self):
+        return repr(self._data)
+
+    def __len__(self):
+        return len(self._data)
+
+    def __delitem__(self, key):
+        del self._data[key]
+
+    def clear(self):
+        return self._data.clear()
+
+    def copy(self):
+        return self._data.copy()
+
+    def has_key(self, k):
+        return k in self._data
+
+    def update(self, *args, **kwargs):
+        return self._data.update(*args, **kwargs)
+
+    def keys(self):
+        return self._data.keys()
+
+    def values(self):
+        return self._data.values()
+
+    def items(self):
+        return self._data.items()
+
+    def pop(self, *args):
+        return self._data.pop(*args)
+
+    def __cmp__(self, dict_):
+        return self.__cmp__(self._data, dict_)
+
+    def __contains__(self, item):
+        return item in self._data
+
+    def __iter__(self):
+        return iter(self._data)

mongoengine/fields.py

@@ -16,6 +16,8 @@
 from bson.decimal128 import Decimal128, create_decimal128_context
 from pymongo import ReturnDocument
 
+from mongoengine.base.datastructures import RawDict
+
 try:
     import dateutil
 except ImportError:
@@ -81,6 +83,7 @@
     "SortedListField",
     "EmbeddedDocumentListField",
     "DictField",
+    "LazyDictField",
     "MapField",
     "ReferenceField",
     "CachedReferenceField",
@@ -1035,6 +1038,7 @@ def key_starts_with_dollar(d):
             return True
 
 
+# TODO: make a LazyDictField that lazily deferences on access
 class DictField(ComplexBaseField):
     """A dictionary field that wraps a standard Python dictionary. This is
     similar to an embedded document, but the structure is not defined.
@@ -1089,6 +1093,66 @@ def prepare_query_value(self, op, value):
         return super().prepare_query_value(op, value)
 
 
+class LazyDictField(ComplexBaseField):
+    """A lazy dictionary field that wraps a standard Python dictionary.
+    Unlike the :class:`~mongoengine.fields.DictField`, it will
+    **not** be automatically deserialized. Manual deserialization must be triggered
+    using the ``deserialize()`` method.
+
+    .. note::
+        Required means it cannot be empty - as the default for DictFields is {}
+    """
+
+    def __init__(self, field=None, *args, **kwargs):
+        kwargs.setdefault("default", dict)
+        super().__init__(*args, field=field, **kwargs)
+        self.set_auto_dereferencing(False)
+
+    def validate(self, value):
+        """Make sure that a list of valid fields is being used."""
+        if not isinstance(value, dict):
+            self.error("Only dictionaries may be used in a DictField")
+
+        if key_not_string(value):
+            msg = "Invalid dictionary key - documents must have only string keys"
+            self.error(msg)
+
+        # Following condition applies to MongoDB >= 3.6
+        # older Mongo has stricter constraints but
+        # it will be rejected upon insertion anyway
+        # Having a validation that depends on the MongoDB version
+        # is not straightforward as the field isn't aware of the connected Mongo
+        if key_starts_with_dollar(value):
+            self.error(
+                'Invalid dictionary key name - keys may not startswith "$" characters'
+            )
+        super().validate(value)
+
+    def lookup_member(self, member_name):
+        return DictField(db_field=member_name)
+
+    def prepare_query_value(self, op, value):
+        match_operators = [*STRING_OPERATORS]
+
+        if op in match_operators and isinstance(value, str):
+            return StringField().prepare_query_value(op, value)
+
+        if hasattr(
+            self.field, "field"
+        ):  # Used for instance when using DictField(ListField(IntField()))
+            if op in ("set", "unset") and isinstance(value, dict):
+                return {
+                    k: self.field.prepare_query_value(op, v) for k, v in value.items()
+                }
+            return self.field.prepare_query_value(op, value)
+
+        return super().prepare_query_value(op, value)
+
+    def to_python(self, value):
+        self._data = RawDict(value, super().to_python)
+        return self._data
+
+
 class MapField(DictField):
     """A field that maps a name to a specified field type. Similar to
     a DictField, except the 'value' of each item must match the specified