implements #1, extend deferred attribute descriptor to always attempt coercion to enum type instance on field set

Author: bckohan

README.rst

@@ -80,7 +80,6 @@ accessible as their enumeration type rather than by-value:**
         txt_enum=MyModel.TextEnum.VALUE1,
         int_enum=3  # by-value assignment also works
     )
-    instance.refresh_from_db()
 
     assert instance.txt_enum == MyModel.TextEnum('V1')
     assert instance.txt_enum.label == 'Value 1'
@@ -129,7 +128,6 @@ possible very rich enumeration fields.
 
     # save by any symmetric value
     instance.color = 'FF0000'
-    instance.full_clean()
 
     # access any enum property right from the model field
     assert instance.color.hex == 'ff0000'

django_enum/fields.py

@@ -26,21 +26,40 @@
     PositiveSmallIntegerField,
     SmallIntegerField,
 )
+from django.db.models.query_utils import DeferredAttribute
 
 T = TypeVar('T')  # pylint: disable=C0103
 
 
 def with_typehint(baseclass: Type[T]) -> Type[T]:
     """
-    Change inheritance to add Field type hints when . This is just more simple
-    than defining a Protocols - revisit if Django provides Field protocol -
-    should also just be a way to create a Protocol from a class?
+    Change inheritance to add Field type hints when type checking is running.
+    This is just more simple than defining a Protocol - revisit if Django
+    provides Field protocol - should also just be a way to create a Protocol
+    from a class?
+
+    This is icky but it works - revisit in future.
     """
     if TYPE_CHECKING:
         return baseclass  # pragma: no cover
     return object  # type: ignore
 
 
+class ToPythonDeferredAttribute(DeferredAttribute):
+    """
+    Extend DeferredAttribute descriptor to run a field's to_python method on a
+    value anytime it is set on the model. This is used to ensure a EnumFields
+    on models are always of their Enum type.
+    """
+
+    def __set__(self, instance: Model, value: Any):
+        try:
+            instance.__dict__[self.field.name] = self.field.to_python(value)
+        except ValidationError:
+            # Django core fields allow assignment of any value, we do the same
+            instance.__dict__[self.field.name] = value
+
+
 class EnumMixin(
     # why can't mypy handle the line below?
     with_typehint(Field)  # type: ignore
@@ -63,6 +82,8 @@ class EnumMixin(
     strict: bool = True
     coerce: bool = True
 
+    descriptor_class = ToPythonDeferredAttribute
+
     def _coerce_to_value_type(self, value: Any) -> Choices:
         """Coerce the value to the enumerations value type"""
         # note if enum type is int and a floating point is passed we could get
@@ -92,7 +113,7 @@ def _try_coerce(self, value: Any, force: bool = False) -> Union[Choices, Any]:
             (self.coerce or force)
             and self.enum is not None
             and not isinstance(value, self.enum)
-        ): # pylint: disable=R0801
+        ):
             try:
                 value = self.enum(value)
             except (TypeError, ValueError):

django_enum/filters.py

@@ -7,7 +7,6 @@
 from django_enum.fields import EnumMixin
 from django_enum.forms import EnumChoiceField
 
-
 try:
     from django_filters import ChoiceFilter, Filter, filterset
 

django_enum/forms.py

@@ -6,7 +6,6 @@
 from django.forms.fields import ChoiceField
 from django.forms.widgets import Select
 
-
 __all__ = ['NonStrictSelect', 'EnumChoiceField']
 
 

django_enum/tests/tests.py

@@ -6,7 +6,7 @@
 from django.core import serializers
 from django.core.exceptions import ValidationError
 from django.core.management import call_command
-from django.db import transaction
+from django.db import connection, transaction
 from django.db.models import Q
 from django.http import QueryDict
 from django.test import Client, TestCase
@@ -80,6 +80,22 @@ class EnumTypeMixin:
     type at the specific test in question.
     """
 
+    fields = [
+        'small_pos_int',
+        'small_int',
+        'pos_int',
+        'int',
+        'big_pos_int',
+        'big_int',
+        'constant',
+        'text',
+        'dj_int_enum',
+        'dj_text_enum',
+        'non_strict_int',
+        'non_strict_text',
+        'no_coerce',
+    ]
+
     @property
     def SmallPosIntEnum(self):
         return self.MODEL_CLASS._meta.get_field('small_pos_int').enum
@@ -167,6 +183,53 @@ def test_basic_save(self):
             self.assertEqual(self.MODEL_CLASS.objects.filter(**{param: value}).count(), 1)
         self.MODEL_CLASS.objects.all().delete()
 
+    def test_to_python_deferred_attribute(self):
+        obj = self.MODEL_CLASS.objects.create(**self.create_params)
+        with self.assertNumQueries(1):
+            obj2 = self.MODEL_CLASS.objects.only('id').get(pk=obj.pk)
+
+        for field in [
+            field.name for field in self.MODEL_CLASS._meta.fields
+            if field.name != 'id'
+        ]:
+            # each of these should result in a db query
+            with self.assertNumQueries(1):
+                self.assertEqual(
+                    getattr(obj, field),
+                    getattr(obj2, field)
+                )
+
+            with self.assertNumQueries(2):
+                self.assertEqual(
+                    getattr(
+                        self.MODEL_CLASS.objects.defer(field).get(pk=obj.pk),
+                        field
+                    ),
+                    getattr(obj, field),
+                )
+
+        # test that all coerced fields are coerced to the Enum type on
+        # assignment - this also tests symmetric value assignment in the
+        # derived class
+        set_tester = self.MODEL_CLASS()
+        for field, value in self.values_params.items():
+            setattr(set_tester, field, getattr(value, 'value', value))
+            if self.MODEL_CLASS._meta.get_field(field).coerce:
+                try:
+                    self.assertIsInstance(getattr(set_tester, field), self.enum_type(field))
+                except AssertionError:
+                    self.assertFalse(self.MODEL_CLASS._meta.get_field(field).strict)
+                    self.assertIsInstance(getattr(set_tester, field), self.enum_primitive(field))
+            else:
+                self.assertNotIsInstance(getattr(set_tester, field), self.enum_type(field))
+                self.assertIsInstance(getattr(set_tester, field), self.enum_primitive(field))
+
+        # extra verification - save and make sure values are expected
+        set_tester.save()
+        set_tester.refresh_from_db()
+        for field, value in self.values_params.items():
+            self.assertEqual(getattr(set_tester, field), value)
+
     def test_integer_choices(self):
         self.do_test_integer_choices()
 
@@ -731,7 +794,6 @@ def test_instance(self):
     def test_data(self):
         form = self.FORM_CLASS(data=self.model_params)
         form.full_clean()
-        print(form.errors)
         self.assertTrue(form.is_valid())
         for field, value in self.model_params.items():
             self.verify_field(form, field, value)
@@ -3075,14 +3137,12 @@ def test_mapboxstyle(self):
 
             # uri's are symmetric
             map_obj.style = 'mapbox://styles/mapbox/light-v10'
-            map_obj.full_clean()
             self.assertTrue(map_obj.style == Map.MapBoxStyle.LIGHT)
             self.assertTrue(map_obj.style == 3)
             self.assertTrue(map_obj.style == 'light')
 
             # so are labels (also case insensitive)
             map_obj.style = 'satellite streets'
-            map_obj.full_clean()
             self.assertTrue(map_obj.style == Map.MapBoxStyle.SATELLITE_STREETS)
 
             # when used in API calls (coerced to strings) - they "do the right
@@ -3110,7 +3170,6 @@ def test_color(self):
 
             # save by any symmetric value
             instance.color = 'FF0000'
-            instance.full_clean()
 
             # access any property right from the model field
             self.assertTrue(instance.color.hex == 'ff0000')
@@ -3162,8 +3221,7 @@ def test_strict(self):
 
             # set to a valid EnumType value
             obj.non_strict = '1'
-            obj.full_clean()
-            # when accessed from the db or after clean, will be an EnumType instance
+            # when accessed will be an EnumType instance
             self.assertTrue(obj.non_strict is StrictExample.EnumType.ONE)
 
             # we can also store any string less than or equal to length 10
@@ -3178,7 +3236,6 @@ def test_basic(self):
                 txt_enum=MyModel.TextEnum.VALUE1,
                 int_enum=3  # by-value assignment also works
             )
-            instance.refresh_from_db()
 
             self.assertTrue(instance.txt_enum == MyModel.TextEnum('V1'))
             self.assertTrue(instance.txt_enum.label == 'Value 1')
@@ -3193,7 +3250,7 @@ def test_basic(self):
                 int_enum=3
             )
 
-            instance.txt_enum='AA'
+            instance.txt_enum = 'AA'
             self.assertRaises(ValidationError, instance.full_clean)
 
         def test_no_coerce(self):

doc/source/index.rst

@@ -50,7 +50,6 @@ accessible as their enumeration type rather than by-value:**
         txt_enum=MyModel.TextEnum.VALUE1,
         int_enum=3  # by-value assignment also works
     )
-    instance.refresh_from_db()
 
     assert instance.txt_enum == MyModel.TextEnum('V1')
     assert instance.txt_enum.label == 'Value 1'
@@ -92,7 +91,6 @@ enum-properties_ which makes possible very rich enumeration fields.
 
     # save by any symmetric value or enum type instance
     instance.color = 'FF0000'
-    instance.full_clean()
     assert instance.color.hex == 'ff0000'
     instance.save()
 

doc/source/usage.rst

@@ -37,8 +37,8 @@ following exceptions:
 
 .. code:: python
 
-    # txt_enum fields, when populated from the db, or after full_clean will be
-    # an instance of the TextEnum type:
+    # txt_enum fields will always be an instance of the TextEnum type, unless
+    # set to a value that is not part of the enumeration
 
     assert isinstance(MyModel.objects.first().txt_enum, MyModel.TextEnum)
     assert not isinstance(MyModel.objects.first().txt_choices, MyModel.TextEnum)
@@ -108,8 +108,7 @@ data where no ``Enum`` type coercion is possible.
 
     # set to a valid EnumType value
     obj.non_strict = '1'
-    obj.full_clean()
-    # when accessed from the db or after clean, will be an EnumType instance
+    # when accessed will be an EnumType instance
     assert obj.non_strict is StrictExample.EnumType.ONE
 
     # we can also store any string less than or equal to length 10
@@ -140,9 +139,8 @@ filter by ``Enum`` instance or any symmetric value:
 
     # set to a valid EnumType value
     obj.non_strict = '1'
-    obj.full_clean()
 
-    # when accessed from the db or after clean, will be the primitive value
+    # when accessed will be the primitive value
     assert obj.non_strict == '1'
     assert isinstance(obj.non_strict, str)
     assert not isinstance(obj.non_strict, StrictExample.EnumType)
@@ -200,7 +198,6 @@ values that can be symmetrically mapped back to enumeration values:
 
     # save by any symmetric value
     instance.color = 'FF0000'
-    instance.full_clean()
 
     # access any enum property right from the model field
     assert instance.color.hex == 'ff0000'