closes #5, EnumChoiceField is now used by default in ModelForms to represent EnumFields

Author: bckohan

django_enum/drf.py

@@ -1,5 +1,6 @@
 """Support for django rest framework symmetric serialization"""
 
+__all__ = ['EnumField']
 
 try:
     from typing import Any, Type, Union

django_enum/fields.py

@@ -27,6 +27,7 @@
     SmallIntegerField,
 )
 from django.db.models.query_utils import DeferredAttribute
+from django_enum.forms import EnumChoiceField, NonStrictSelect
 
 T = TypeVar('T')  # pylint: disable=C0103
 
@@ -55,7 +56,7 @@ class ToPythonDeferredAttribute(DeferredAttribute):
     def __set__(self, instance: Model, value: Any):
         try:
             instance.__dict__[self.field.name] = self.field.to_python(value)
-        except ValidationError:
+        except (ValidationError, ValueError):
             # Django core fields allow assignment of any value, we do the same
             instance.__dict__[self.field.name] = value
 
@@ -131,8 +132,8 @@ def _try_coerce(
                     value = self.enum(value)
                 except (TypeError, ValueError) as err:
                     if self.strict or not isinstance(
-                            value,
-                            type(self.enum.values[0])
+                        value,
+                        type(self.enum.values[0])
                     ):
                         raise ValueError(
                             f"'{value}' is not a valid {self.enum.__name__} "
@@ -273,8 +274,25 @@ def validate(self, value: Any, model_instance: Model):
                 params={'value': value}
             ) from err
 
-    # def formfield(self, form_class=None, choices_form_class=None, **kwargs):
-    #    pass
+    def formfield(self, form_class=None, choices_form_class=None, **kwargs):
+
+        # super().formfield deletes anything unrecognized from kwargs that
+        #   we try to pass in. Very annoying because we have to
+        #   un-encapsulate some of this initialization logic, this makes our
+        #   EnumChoiceField pretty ugly!
+
+        if not self.strict:
+            kwargs.setdefault('widget', NonStrictSelect)
+
+        form_field = super().formfield(
+            form_class=form_class,
+            choices_form_class=choices_form_class or EnumChoiceField,
+            **kwargs
+        )
+
+        form_field.enum = self.enum
+        form_field.strict = self.strict
+        return form_field
 
 
 class EnumCharField(EnumMixin, CharField):

django_enum/forms.py

@@ -1,9 +1,9 @@
 """Enumeration support for django model forms"""
-from typing import Any, Iterable, List, Tuple, Type, Union
+from typing import Any, Iterable, List, Optional, Tuple, Type, Union
 
 from django.core.exceptions import ValidationError
 from django.db.models import Choices
-from django.forms.fields import ChoiceField
+from django.forms.fields import TypedChoiceField
 from django.forms.widgets import Select
 
 __all__ = ['NonStrictSelect', 'EnumChoiceField']
@@ -41,7 +41,7 @@ def render(self, *args, **kwargs):
         return super().render(*args, **kwargs)
 
 
-class EnumChoiceField(ChoiceField):
+class EnumChoiceField(TypedChoiceField):
     """
     The default ``ChoiceField`` will only accept the base enumeration values.
     Use this field on forms to accept any value mappable to an enumeration
@@ -60,68 +60,105 @@ class EnumChoiceField(ChoiceField):
     :param kwargs: Any additional parameters to pass to ChoiceField base class.
     """
 
-    enum: Type[Choices]
-    strict: bool = True
+    enum_: Optional[Type[Choices]] = None
+    strict_: bool = True
     empty_value: Any = ''
     empty_values: List[Any]
+    choices: Iterable[Tuple[Any, Any]]
+
+    @property
+    def strict(self):
+        """strict fields allow non-enumeration values"""
+        return self.strict_
+
+    @strict.setter
+    def strict(self, strict):
+        self.strict_ = strict
+
+    @property
+    def enum(self):
+        """the class of the enumeration"""
+        return self.enum_
+
+    @enum.setter
+    def enum(self, enum):
+        self.enum_ = enum
+        self.choices = self.choices or getattr(
+            self.enum,
+            'choices',
+            self.choices
+        )
+        # remove any of our valid enumeration values or symmetric properties
+        # from our empty value list if there exists an equivalency
+        for empty in self.empty_values:
+            for enum_val in self.enum:
+                if empty == enum_val:
+                    # copy the list instead of modifying the class's
+                    self.empty_values = [
+                        empty for empty in self.empty_values
+                        if empty != enum_val
+                    ]
+                    if empty == self.empty_value:
+                        if self.empty_values:
+                            self.empty_value = self.empty_values[0]
+                        else:
+                            raise ValueError(
+                                f'Enumeration value {repr(enum_val)} is'
+                                f'equivalent to {self.empty_value}, you must '
+                                f'specify a non-conflicting empty_value.'
+                            )
 
     def __init__(
             self,
-            enum: Type[Choices],
+            enum: Optional[Type[Choices]] = None,
             *,
             empty_value: Any = _Unspecified,
-            strict: bool = strict,
+            strict: bool = strict_,
             choices: Iterable[Tuple[Any, str]] = (),
             **kwargs
     ):
-        self.enum = enum
         self.strict = strict
         if not self.strict:
             kwargs.setdefault('widget', NonStrictSelect)
 
+        self.empty_values = kwargs.pop('empty_values', self.empty_values)
+
         super().__init__(
-            choices=choices or getattr(self.enum, 'choices', ()),
+            choices=choices or getattr(self.enum, 'choices', choices),
+            coerce=kwargs.pop('coerce', self.coerce),
             **kwargs
         )
 
         if empty_value is not _Unspecified:
-            self.empty_values.insert(0, empty_value)
+            if empty_value not in self.empty_values:
+                self.empty_values.insert(0, empty_value)
             self.empty_value = empty_value
 
-        # remove any of our valid enumeration values or symmetric properties
-        # from our empty value list if there exists an equivalency
-        for empty in self.empty_values:
-            for enum_val in self.enum:
-                if empty == enum_val:
-                    # copy the list instead of modifying the class's
-                    self.empty_values = [
-                        empty for empty in self.empty_values
-                        if empty != enum_val
-                    ]
-                    if empty == self.empty_value:
-                        raise ValueError(
-                            f'Enumeration value {repr(enum_val)} is equivalent'
-                            f' to {self.empty_value}, you must specify a '
-                            f'non-conflicting empty_value.'
-                        )
+        if enum:
+            self.enum = enum
 
     def _coerce_to_value_type(self, value: Any) -> Any:
         """Coerce the value to the enumerations value type"""
         return type(self.enum.values[0])(value)
 
-    def _coerce(self, value: Any) -> Union[Choices, Any]:
+    def coerce(  # pylint: disable=E0202
+            self, value: Any
+    ) -> Union[Choices, Any]:
         """
         Attempt conversion of value to an enumeration value and return it
         if successful.
 
+        .. note::
+
+            When used to represent a model field, by default the model field's
+            to_python method will be substituted for this method.
+
         :param value: The value to convert
         :raises ValidationError: if a valid return value cannot be determined.
         :return: An enumeration value or the canonical empty value if value is
             one of our empty_values, or the value itself if this is a
             non-strict field and the value is of a matching primitive type
         """
-        if value in self.empty_values:
-            return self.empty_value
         if (
             self.enum is not None and
             not isinstance(value, self.enum)  # pylint: disable=R0801
@@ -134,8 +171,8 @@ def _coerce(self, value: Any) -> Union[Choices, Any]:
                     value = self.enum(value)
                 except (TypeError, ValueError) as err:
                     if self.strict or not isinstance(
-                            value,
-                            type(self.enum.values[0])
+                        value,
+                        type(self.enum.values[0])
                     ):
                         raise ValidationError(
                             f'{value} is not a valid {self.enum}.',

django_enum/tests/djenum/forms.py

@@ -1,34 +1,8 @@
 from django.forms import ModelForm
-from django_enum import EnumChoiceField
-from django_enum.tests.djenum.enums import (
-    BigIntEnum,
-    BigPosIntEnum,
-    Constants,
-    DJIntEnum,
-    DJTextEnum,
-    IntEnum,
-    PosIntEnum,
-    SmallIntEnum,
-    SmallPosIntEnum,
-    TextEnum,
-)
 from django_enum.tests.djenum.models import EnumTester
 
 
 class EnumTesterForm(ModelForm):
-    small_pos_int = EnumChoiceField(SmallPosIntEnum)
-    small_int = EnumChoiceField(SmallIntEnum)
-    pos_int = EnumChoiceField(PosIntEnum)
-    int = EnumChoiceField(IntEnum)
-    big_pos_int = EnumChoiceField(BigPosIntEnum)
-    big_int = EnumChoiceField(BigIntEnum)
-    constant = EnumChoiceField(Constants)
-    text = EnumChoiceField(TextEnum)
-    dj_int_enum = EnumChoiceField(DJIntEnum)
-    dj_text_enum = EnumChoiceField(DJTextEnum)
-    non_strict_int = EnumChoiceField(SmallPosIntEnum, strict=False)
-    non_strict_text = EnumChoiceField(TextEnum, strict=False)
-    no_coerce = EnumChoiceField(SmallPosIntEnum)
 
     class Meta:
         model = EnumTester

django_enum/tests/djenum/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 3.2.15 on 2022-08-12 04:26
+# Generated by Django 3.2.15 on 2022-08-13 02:32
 
 import django_enum.fields
 from django.db import migrations, models
@@ -12,6 +12,13 @@ class Migration(migrations.Migration):
     ]
 
     operations = [
+        migrations.CreateModel(
+            name='BadDefault',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('non_strict_int', django_enum.fields.EnumPositiveSmallIntegerField(blank=True, choices=[(0, 'Value 1'), (2, 'Value 2'), (32767, 'Value 32767')], default=5, null=True)),
+            ],
+        ),
         migrations.CreateModel(
             name='EnumTester',
             fields=[

django_enum/tests/djenum/models.py

@@ -100,3 +100,14 @@ def get_absolute_url(self):
 
     class Meta:
         ordering = ('id',)
+
+
+class BadDefault(models.Model):
+
+    # Non-strict
+    non_strict_int = EnumField(
+        SmallPosIntEnum,
+        null=True,
+        default=5,
+        blank=True
+    )

django_enum/tests/djenum/urls.py

@@ -4,9 +4,6 @@
     EnumTesterCreateView,
     EnumTesterDeleteView,
     EnumTesterDetailView,
-    EnumTesterFormCreateView,
-    EnumTesterFormDeleteView,
-    EnumTesterFormView,
     EnumTesterListView,
     EnumTesterUpdateView,
 )
@@ -18,11 +15,8 @@
     path('enum/<int:pk>', EnumTesterDetailView.as_view(), name='enum-detail'),
     path('enum/list/', EnumTesterListView.as_view(), name='enum-list'),
     path('enum/add/', EnumTesterCreateView.as_view(), name='enum-add'),
-    path('enum/form/add/', EnumTesterFormCreateView.as_view(), name='enum-form-add'),
     path('enum/<int:pk>/', EnumTesterUpdateView.as_view(), name='enum-update'),
-    path('enum/form/<int:pk>/', EnumTesterFormView.as_view(), name='enum-form-update'),
-    path('enum/<int:pk>/delete/', EnumTesterDeleteView.as_view(), name='enum-delete'),
-    path('enum/form/<int:pk>/delete/', EnumTesterFormDeleteView.as_view(), name='enum-form-delete')
+    path('enum/<int:pk>/delete/', EnumTesterDeleteView.as_view(), name='enum-delete')
 ]