remove generic support

Author: timgraham

django_mongodb/fields/embedded_model.py

@@ -1,13 +1,11 @@
-from importlib import import_module
-
-from django.db import IntegrityError, models
+from django.db import models
 from django.db.models.fields.related import lazy_related_operation
 
 
 class EmbeddedModelField(models.Field):
     """Field that stores a model instance."""
 
-    def __init__(self, embedded_model=None, *args, **kwargs):
+    def __init__(self, embedded_model, *args, **kwargs):
         """
         `embedded_model` is the model class of the instance that will be
         stored. Like other relational fields, it may also be passed as a
@@ -20,8 +18,7 @@ def deconstruct(self):
         name, path, args, kwargs = super().deconstruct()
         if path.startswith("django_mongodb.fields.embedded_model"):
             path = path.replace("django_mongodb.fields.embedded_model", "django_mongodb.fields")
-        if self.embedded_model:
-            kwargs["embedded_model"] = self.embedded_model
+        kwargs["embedded_model"] = self.embedded_model
         return name, path, args, kwargs
 
     def get_internal_type(self):
@@ -50,60 +47,26 @@ def _resolve_lookup(_, resolved_model):
 
     model = property(lambda self: self._model, _set_model)
 
-    def stored_model(self, column_values):
-        """
-        Return the fixed embedded_model this field was initialized
-        with (typed embedding) or tries to determine the model from
-        _module / _model keys stored together with column_values
-        (untyped embedding).
-
-        Give precedence to the field's definition model, as silently using a
-        differing serialized one could hide some data integrity problems.
-
-        Note that a single untyped EmbeddedModelField may process
-        instances of different models (especially when used as a type
-        of a collection field).
-        """
-        module = column_values.pop("_module", None)
-        model = column_values.pop("_model", None)
-        if self.embedded_model is not None:
-            return self.embedded_model
-        if module is not None:
-            return getattr(import_module(module), model)
-        raise IntegrityError(
-            "Untyped EmbeddedModelField trying to load data without serialized model class info."
-        )
-
     def from_db_value(self, value, expression, connection):
         return self.to_python(value)
 
     def to_python(self, value):
         """
         Passes embedded model fields' values through embedded fields
-        to_python methods and reinstiatates the embedded instance.
-
-        We expect to receive a field.attname => value dict together
-        with a model class from back-end database deconversion (which
-        needs to know fields of the model beforehand).
+        to_python() and reinstiatates the embedded instance.
         """
-        # Either the model class has already been determined during
-        # deconverting values from the database or we've got a dict
-        # from a deserializer that may contain model class info.
-        if isinstance(value, tuple):
-            embedded_model, attribute_values = value
-        elif isinstance(value, dict):
-            embedded_model = self.stored_model(value)
-            attribute_values = value
-        else:
+        if value is None:
+            return None
+        if not isinstance(value, dict):
             return value
         # Create the model instance.
-        instance = embedded_model(
+        instance = self.embedded_model(
             **{
                 # Pass values through respective fields' to_python(), leaving
                 # fields for which no value is specified uninitialized.
-                field.attname: field.to_python(attribute_values[field.attname])
-                for field in embedded_model._meta.fields
-                if field.attname in attribute_values
+                field.attname: field.to_python(value[field.attname])
+                for field in self.embedded_model._meta.fields
+                if field.attname in value
             }
         )
         instance._state.adding = False
@@ -115,21 +78,17 @@ def get_db_prep_save(self, embedded_instance, connection):
         fields and passes a field => value mapping down to database
         type conversions.
 
-        The embedded instance will be saved as a column => value dict
-        in the end (possibly augmented with info about instance's model
-        for untyped embedding), but because we need to apply database
-        type conversions on embedded instance fields' values and for
-        these we need to know fields those values come from, we need to
-        entrust the database layer with creating the dict.
+        The embedded instance will be saved as a column => value dict, but
+        because we need to apply database type conversions on embedded instance
+        fields' values and for these we need to know fields those values come
+        from, we need to entrust the database layer with creating the dict.
         """
         if embedded_instance is None:
             return None
-        # The field's value should be an instance of the model given in
-        # its declaration or at least of some model.
-        embedded_model = self.embedded_model or models.Model
-        if not isinstance(embedded_instance, embedded_model):
+        if not isinstance(embedded_instance, self.embedded_model):
             raise TypeError(
-                f"Expected instance of type {embedded_model!r}, not {type(embedded_instance)!r}."
+                f"Expected instance of type {self.embedded_model!r}, not "
+                f"{type(embedded_instance)!r}."
             )
         # Apply pre_save() and get_db_prep_save() of embedded instance
         # fields, create the field => value mapping to be passed to
@@ -144,14 +103,6 @@ def get_db_prep_save(self, embedded_instance, connection):
             if field.primary_key and value is None:
                 continue
             field_values[field.attname] = value
-        if self.embedded_model is None:
-            # Untyped fields must store model info alongside values.
-            field_values.update(
-                (
-                    ("_module", embedded_instance.__class__.__module__),
-                    ("_model", embedded_instance.__class__.__name__),
-                )
-            )
         # This instance will exist in the database soon.
         # TODO.XXX: Ensure that this doesn't cause race conditions.
         embedded_instance._state.adding = False

tests/model_fields_/models.py

@@ -21,7 +21,6 @@ class DecimalParent(models.Model):
 
 class EmbeddedModelFieldModel(models.Model):
     simple = EmbeddedModelField("EmbeddedModel", null=True, blank=True)
-    untyped = EmbeddedModelField(null=True, blank=True)
     decimal_parent = EmbeddedModelField(DecimalParent, null=True, blank=True)
 
 

tests/model_fields_/test_embedded_model.py

@@ -2,7 +2,6 @@
 from decimal import Decimal
 
 from django.core.exceptions import ValidationError
-from django.db import models
 from django.test import SimpleTestCase, TestCase
 
 from django_mongodb.fields import EmbeddedModelField
@@ -18,98 +17,74 @@
 
 class MethodTests(SimpleTestCase):
     def test_deconstruct(self):
-        field = EmbeddedModelField()
-        name, path, args, kwargs = field.deconstruct()
-        self.assertEqual(path, "django_mongodb.fields.EmbeddedModelField")
-        self.assertEqual(args, [])
-        self.assertEqual(kwargs, {})
-
-    def test_deconstruct_with_model(self):
         field = EmbeddedModelField("EmbeddedModel", null=True)
         name, path, args, kwargs = field.deconstruct()
         self.assertEqual(path, "django_mongodb.fields.EmbeddedModelField")
         self.assertEqual(args, [])
         self.assertEqual(kwargs, {"embedded_model": "EmbeddedModel", "null": True})
 
     def test_validate(self):
-        instance = EmbeddedModelFieldModel(simple=EmbeddedModel(someint=None))
+        obj = EmbeddedModelFieldModel(simple=EmbeddedModel(someint=None))
         # This isn't quite right because "someint" is the field that's non-null.
         msg = "{'simple': ['This field cannot be null.']}"
         with self.assertRaisesMessage(ValidationError, msg):
-            instance.full_clean()
+            obj.full_clean()
 
 
 class QueryingTests(TestCase):
     def assertEqualDatetime(self, d1, d2):
-        """Compares d1 and d2, ignoring microseconds."""
+        """Compare d1 and d2, ignoring microseconds."""
         self.assertEqual(d1.replace(microsecond=0), d2.replace(microsecond=0))
 
     def assertNotEqualDatetime(self, d1, d2):
         self.assertNotEqual(d1.replace(microsecond=0), d2.replace(microsecond=0))
 
     def test_save_load(self):
         EmbeddedModelFieldModel.objects.create(simple=EmbeddedModel(someint="5"))
-        instance = EmbeddedModelFieldModel.objects.get()
-        self.assertIsInstance(instance.simple, EmbeddedModel)
+        obj = EmbeddedModelFieldModel.objects.get()
+        self.assertIsInstance(obj.simple, EmbeddedModel)
         # Make sure get_prep_value is called.
-        self.assertEqual(instance.simple.someint, 5)
+        self.assertEqual(obj.simple.someint, 5)
         # Primary keys should not be populated...
-        self.assertEqual(instance.simple.id, None)
+        self.assertEqual(obj.simple.id, None)
         # ... unless set explicitly.
-        instance.simple.id = instance.id
-        instance.save()
-        instance = EmbeddedModelFieldModel.objects.get()
-        self.assertEqual(instance.simple.id, instance.id)
+        obj.simple.id = obj.id
+        obj.save()
+        obj = EmbeddedModelFieldModel.objects.get()
+        self.assertEqual(obj.simple.id, obj.id)
 
-    def test_save_load_untyped(self):
-        EmbeddedModelFieldModel.objects.create(simple=EmbeddedModel(someint="5"))
-        instance = EmbeddedModelFieldModel.objects.get()
-        self.assertIsInstance(instance.simple, EmbeddedModel)
-        # Make sure get_prep_value is called.
-        self.assertEqual(instance.simple.someint, 5)
-        # Primary keys should not be populated...
-        self.assertEqual(instance.simple.id, None)
-        # ... unless set explicitly.
-        instance.simple.id = instance.id
-        instance.save()
-        instance = EmbeddedModelFieldModel.objects.get()
-        self.assertEqual(instance.simple.id, instance.id)
+    def test_save_load_null(self):
+        EmbeddedModelFieldModel.objects.create(simple=None)
+        obj = EmbeddedModelFieldModel.objects.get()
+        self.assertIsNone(obj.simple)
 
-    def _test_pre_save(self, instance, get_field):
-        # Field.pre_save() is called on embedded model fields.
+    def test_pre_save(self):
+        """Field.pre_save() is called on embedded model fields."""
+        obj = EmbeddedModelFieldModel(simple=EmbeddedModel())
 
-        instance.save()
-        auto_now = get_field(instance).auto_now
-        auto_now_add = get_field(instance).auto_now_add
+        obj.save()
+        auto_now = obj.simple.auto_now
+        auto_now_add = obj.simple.auto_now_add
         self.assertNotEqual(auto_now, None)
         self.assertNotEqual(auto_now_add, None)
 
         time.sleep(1)  # FIXME
-        instance.save()
-        self.assertNotEqualDatetime(get_field(instance).auto_now, get_field(instance).auto_now_add)
+        obj.save()
+        self.assertNotEqualDatetime(obj.simple.auto_now, obj.simple.auto_now_add)
 
-        instance = EmbeddedModelFieldModel.objects.get()
-        instance.save()
+        obj = EmbeddedModelFieldModel.objects.get()
+        obj.save()
         # auto_now_add shouldn't have changed now, but auto_now should.
-        self.assertEqualDatetime(get_field(instance).auto_now_add, auto_now_add)
-        self.assertGreater(get_field(instance).auto_now, auto_now)
-
-    def test_pre_save(self):
-        obj = EmbeddedModelFieldModel(simple=EmbeddedModel())
-        self._test_pre_save(obj, lambda instance: instance.simple)
-
-    def test_pre_save_untyped(self):
-        obj = EmbeddedModelFieldModel(untyped=EmbeddedModel())
-        self._test_pre_save(obj, lambda instance: instance.untyped)
+        self.assertEqualDatetime(obj.simple.auto_now_add, auto_now_add)
+        self.assertGreater(obj.simple.auto_now, auto_now)
 
     def test_error_messages(self):
-        for model_kwargs, expected in (
-            ({"simple": 42}, EmbeddedModel),
-            ({"untyped": 42}, models.Model),
-        ):
-            msg = "Expected instance of type %r" % expected
-            with self.assertRaisesMessage(TypeError, msg):
-                EmbeddedModelFieldModel(**model_kwargs).save()
+        msg = (
+            "Expected instance of type <class 'model_fields_.models.EmbeddedModel'>, "
+            "not <class 'int'>."
+        )
+        with self.assertRaisesMessage(TypeError, msg):
+            EmbeddedModelFieldModel(simple=42).save()
 
     def test_foreign_key_in_embedded_object(self):
         simple = EmbeddedModel(some_relation=Target.objects.create(index=1))