fix #107 fix #106

Author: bckohan

doc/source/changelog.rst

@@ -8,6 +8,8 @@ v2.2.0 (2025-03-23)
 ===================
 
 * Fixed `Enum types that resolve to primitives of str or int but that do not inherit from those types can result in validation errors. <https://github.com/bckohan/django-enum/issues/109>`_
+* Implemented `Support checkboxes for FlagEnumField <https://github.com/bckohan/django-enum/issues/107>`_
+* Implemented `Support radio buttons for EnumChoiceField <https://github.com/bckohan/django-enum/issues/106>`_
 * Implemented `If default is not provided for flag fields it should be Flag(0). <https://github.com/bckohan/django-enum/issues/105>`_
 * Fixed `EnumFlagFields set empty values to Flag(0) when model field has null=True, default=None <https://github.com/bckohan/django-enum/issues/104>`_
 * Fixed `Large enum fields that inherit from binaryfield have editable=False by default <https://github.com/bckohan/django-enum/issues/103>`_

src/django_enum/fields.py

@@ -1241,16 +1241,16 @@ def formfield(self, form_class=None, choices_form_class=None, **kwargs):
         from django_enum.forms import (
             ChoiceFieldMixin,
             EnumFlagField,
-            FlagNonStrictSelectMultiple,
             FlagSelectMultiple,
+            NonStrictFlagSelectMultiple,
         )
 
         kwargs["empty_value"] = None if self.default is None else self.enum(0)
         kwargs.setdefault(
             "widget",
             FlagSelectMultiple(enum=self.enum)
             if self.strict
-            else FlagNonStrictSelectMultiple(enum=self.enum),
+            else NonStrictFlagSelectMultiple(enum=self.enum),
         )
 
         form_field = Field.formfield(

src/django_enum/forms.py

@@ -13,12 +13,19 @@
     TypedChoiceField,
     TypedMultipleChoiceField,
 )
-from django.forms.widgets import ChoiceWidget, Select, SelectMultiple
+from django.forms.widgets import (
+    CheckboxSelectMultiple,
+    ChoiceWidget,
+    RadioSelect,
+    Select,
+    SelectMultiple,
+)
 
 from django_enum.utils import choices as get_choices
 from django_enum.utils import (
     decompose,
     determine_primitive,
+    get_set_bits,
     get_set_values,
     with_typehint,
 )
@@ -27,7 +34,7 @@
     "NonStrictSelect",
     "NonStrictSelectMultiple",
     "FlagSelectMultiple",
-    "FlagNonStrictSelectMultiple",
+    "NonStrictRadioSelect",
     "ChoiceFieldMixin",
     "EnumChoiceField",
     "EnumMultipleChoiceField",
@@ -60,7 +67,7 @@ class _Unspecified:
     """
 
 
-class NonStrictMixin(with_typehint(Select)):  # type: ignore
+class NonStrictMixin:
     """
     Mixin to add non-strict behavior to a widget, this makes sure the set value
     appears as a choice if it is not one of the enumeration choices.
@@ -79,19 +86,53 @@ def render(self, *args, **kwargs):
             choice[0] for choice in self.choices
         ):
             self.choices = list(self.choices) + [(value, str(value))]
-        return super().render(*args, **kwargs)
+        return super().render(*args, **kwargs)  # type: ignore[misc]
+
+
+class NonStrictFlagMixin:
+    """
+    Mixin to add non-strict behavior to a multiple choice flag widget, this makes sure
+    that set flags outside of the enumerated flags will show up as choices. They will
+    be displayed as the index of the set bit.
+    """
+
+    choices: _SelectChoices
+
+    def render(self, *args, **kwargs):
+        """
+        Before rendering if we're a non-strict flag field and bits are set that are
+        not part of our flag enumeration we add them as (integer value, bit index)
+        to our (value, label) choice list.
+        """
+
+        raw_choices = zip(
+            get_set_values(kwargs.get("value")), get_set_bits(kwargs.get("value"))
+        )
+        self.choices = list(self.choices)
+        choice_values = set(choice[0] for choice in self.choices)
+        for value, label in raw_choices:
+            if value not in choice_values:
+                self.choices.append((value, label))
+        return super().render(*args, **kwargs)  # type: ignore[misc]
 
 
 class NonStrictSelect(NonStrictMixin, Select):
     """
-    A Select widget for non-strict EnumChoiceFields that includes any existing
-    non-conforming value as a choice option.
+    This widget renders a select box that includes an option for each value on the
+    enumeration.
     """
 
 
-class FlagSelectMultiple(SelectMultiple):
+class NonStrictRadioSelect(NonStrictMixin, RadioSelect):
     """
-    A SelectMultiple widget for EnumFlagFields.
+    This widget renders a radio select field that includes an option for each value on
+    the enumeration and for any non-value that is set.
+    """
+
+
+class FlagMixin:
+    """
+    This mixin adapts a widget to work with :class:`~enum.IntFlag` types.
     """
 
     enum: Optional[Type[Flag]]
@@ -119,17 +160,45 @@ def format_value(self, value):
         return value
 
 
+class FlagSelectMultiple(FlagMixin, SelectMultiple):
+    """
+    This widget will render :class:`~enum.IntFlag` types as a multi select field with
+    an option for each flag value.
+    """
+
+
+class FlagCheckbox(FlagMixin, CheckboxSelectMultiple):
+    """
+    This widget will render :class:`~enum.IntFlag` types as checkboxes with a checkbox
+    for each flag value.
+    """
+
+
 class NonStrictSelectMultiple(NonStrictMixin, SelectMultiple):
     """
-    A SelectMultiple widget for non-strict EnumFlagFields that includes any
-    existing non-conforming value as a choice option.
+    This widget will render a multi select box that includes an option for each
+    value on the enumeration and for any non-value that is passed in.
     """
 
 
-class FlagNonStrictSelectMultiple(NonStrictMixin, FlagSelectMultiple):
+class NonStrictFlagSelectMultiple(NonStrictFlagMixin, FlagSelectMultiple):
+    """
+    This widget will render a multi select box that includes an option for each flag
+    on the enumeration and also for each bit lot listed in the enumeration that is set
+    on the value.
+
+    Options for extra bits only appear if they are set. You should pass choices to the
+    form field if you want additional options to always appear.
     """
-    A SelectMultiple widget for non-strict EnumFlagFields that includes any
-    existing non-conforming value as a choice option.
+
+
+class NonStrictFlagCheckbox(NonStrictFlagMixin, FlagCheckbox):
+    """
+    This widget will render a checkbox for each flag on the enumeration and also
+    for each bit not listed in the enumeration that is set on the value.
+
+    Checkboxes for extra bits only appear if they are set. You should pass choices to
+    the form field if you want additional checkboxes to always appear.
     """
 
 
@@ -165,7 +234,7 @@ class ChoiceFieldMixin(
 
     choices: _ChoicesParameter
 
-    non_strict_widget: Type[ChoiceWidget] = NonStrictSelect
+    non_strict_widget: Optional[Type[ChoiceWidget]] = NonStrictSelect
 
     def __init__(
         self,
@@ -181,7 +250,7 @@ def __init__(
     ):
         self._strict_ = strict
         self._primitive_ = primitive
-        if not self.strict:
+        if not self.strict and self.non_strict_widget:
             kwargs.setdefault("widget", self.non_strict_widget)
 
         if empty_values is _Unspecified:
@@ -294,7 +363,7 @@ def default_coerce(self, value: Any) -> Any:
 
         :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
+        :returns: 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
         """
@@ -368,7 +437,7 @@ class EnumFlagField(ChoiceFieldMixin, TypedMultipleChoiceField):  # type: ignore
     """
 
     widget = FlagSelectMultiple
-    non_strict_widget = FlagNonStrictSelectMultiple
+    non_strict_widget = NonStrictFlagSelectMultiple
 
     def __init__(
         self,
@@ -380,10 +449,12 @@ def __init__(
         choices: _ChoicesParameter = (),
         **kwargs,
     ):
-        kwargs.setdefault(
-            "widget",
-            self.widget(enum=enum) if strict else self.non_strict_widget(enum=enum),  # type: ignore[call-arg]
+        widget = kwargs.get(
+            "widget", self.widget if self.strict else self.non_strict_widget
         )
+        if isinstance(widget, type) and issubclass(widget, FlagMixin):
+            widget = widget(enum=enum)
+        kwargs["widget"] = widget
         super().__init__(
             enum=enum,
             empty_value=(

src/django_enum/utils.py

@@ -17,6 +17,7 @@
     "with_typehint",
     "SupportedPrimitive",
     "decimal_params",
+    "get_set_values",
     "get_set_bits",
 ]
 

tests/djenum/admin.py

@@ -1,13 +1,22 @@
 from django.contrib import admin
 
-from django.forms import ModelForm
+from django.forms import ModelForm, RadioSelect
+from django_enum.forms import (
+    NonStrictRadioSelect,
+    FlagCheckbox,
+    NonStrictFlagCheckbox,
+)
+from django_enum.utils import decompose
+
+from tests.djenum.enums import TextEnum, GNSSConstellation
 from tests.djenum.models import (
     AdminDisplayBug35,
     EnumTester,
     NullBlankFormTester,
     NullableBlankFormTester,
     Bug53Tester,
     NullableStrFormTester,
+    AltWidgetTester,
 )
 
 admin.site.register(EnumTester)
@@ -23,3 +32,43 @@ class AdminDisplayBug35Admin(admin.ModelAdmin):
 
 
 admin.site.register(AdminDisplayBug35, AdminDisplayBug35Admin)
+
+
+class AltWidgetAdminForm(ModelForm):
+    class Meta:
+        model = AltWidgetTester
+        fields = "__all__"
+        widgets = {
+            "text": RadioSelect,
+            "text_null": RadioSelect,
+            "text_non_strict": NonStrictRadioSelect,
+            "constellation": FlagCheckbox,
+            "constellation_null": FlagCheckbox,
+            "constellation_non_strict": NonStrictFlagCheckbox,
+        }
+
+
+class AltWidgetAdmin(admin.ModelAdmin):
+    form = AltWidgetAdminForm
+    list_display = (
+        "text",
+        "text_null",
+        "text_non_strict",
+        "constellations",
+        "constellations_null",
+        "constellations_non_strict",
+    )
+
+    def constellations(self, obj):
+        return ", ".join([str(c.name) for c in decompose(obj.constellation)])
+
+    def constellations_null(self, obj):
+        if obj.constellation_null is None:
+            return "None"
+        return ", ".join([str(c.name) for c in decompose(obj.constellation_null)])
+
+    def constellations_non_strict(self, obj):
+        return ", ".join([str(c.name) for c in decompose(obj.constellation_non_strict)])
+
+
+admin.site.register(AltWidgetTester, AltWidgetAdmin)

tests/djenum/enums.py

@@ -390,3 +390,11 @@ class StrTestEnum(str, Enum):
 
     def __str__(self):
         return self.value
+
+
+class GNSSConstellation(IntFlag):
+    GPS = 1 << 0
+    GLONASS = 1 << 1
+    GALILEO = 1 << 2
+    BEIDOU = 1 << 3
+    QZSS = 1 << 4

tests/djenum/models.py

@@ -40,6 +40,7 @@
     TextEnum,
     TimeEnum,
     NullableConstants,
+    GNSSConstellation,
 )
 
 
@@ -381,3 +382,16 @@ class Bug53Tester(models.Model):
     )
     int_blank_null_false = EnumField(ExternEnum, null=False, blank=True)
     int_blank_null_true = EnumField(ExternEnum, null=True, blank=True)
+
+
+class AltWidgetTester(models.Model):
+    text = EnumField(TextEnum, default=TextEnum.VALUE1)
+    text_null = EnumField(TextEnum, default=None, blank=True, null=True)
+    text_non_strict = EnumField(
+        TextEnum, default=TextEnum.VALUE1, strict=False, max_length=10
+    )
+    constellation = EnumField(GNSSConstellation)
+    constellation_null = EnumField(
+        GNSSConstellation, null=True, blank=True, default=None
+    )
+    constellation_non_strict = EnumField(GNSSConstellation, strict=False)