fix #105

Author: bckohan

README.md

@@ -94,9 +94,9 @@ Many packages aim to ease usage of Python enumerations as model fields. Most wer
 
     class Permissions(IntFlag):
 
-        READ = 1**2
-        WRITE = 2**2
-        EXECUTE = 3**2
+        READ    = 1 << 0
+        WRITE   = 1 << 1
+        EXECUTE = 1 << 2
 
 
     class FlagExample(models.Model):

doc/source/changelog.rst

@@ -7,6 +7,10 @@ Change Log
 v2.2.0 (2025-03-XX)
 ===================
 
+* 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>`_
+* Fixed `EnumFlagField breaks for Flag types that are not constructible from lists of values <https://github.com/bckohan/django-enum/issues/102>`_
 * Implemented `Test all example code in the docs <https://github.com/bckohan/django-enum/issues/99>`_
 * Implemented `Use intersphinx for doc references <https://github.com/bckohan/django-enum/issues/98>`_
 * Implemented `Support Django 5.2 <https://github.com/bckohan/django-enum/issues/96>`_
@@ -40,6 +44,7 @@ v2.0.0 (2024-09-09)
 * Completed `Reorganize tests <https://github.com/bckohan/django-enum/issues/70>`_
 * Completed `Switch linting and formatting to ruff <https://github.com/bckohan/django-enum/issues/62>`_
 * Implemented `Install django-stubs when running static type checks. <https://github.com/bckohan/django-enum/issues/60>`_
+* Fixed `When a character enum field allows null and blank=True, form fields and drf fields allow '' to pass through causing errors. <https://github.com/bckohan/django-enum/issues/53>`_
 * Implemented `Supply a mixin for DRF ModelSerializers that instantiates the provided DRF EnumField type for model EnumFields. <https://github.com/bckohan/django-enum/issues/47>`_
 * Implemented `EnumField's should inherit from common base titled EnumField <https://github.com/bckohan/django-enum/issues/46>`_
 * Implemented `Add database constraints on enum fields by default. <https://github.com/bckohan/django-enum/issues/45>`_

justfile

@@ -47,6 +47,12 @@ install *OPTS="--all-extras":
 install-docs:
     uv sync --group docs --all-extras
 
+# run the development server
+runserver:
+    @just manage makemigrations
+    @just manage migrate
+    @just manage runserver 8027
+
 [script]
 _lock-python:
     import tomlkit

src/django_enum/fields.py

@@ -293,7 +293,10 @@ def lte(tpl1: Tuple[int, int], tpl2: Tuple[int, int]) -> bool:
                     )
 
             return field_cls(
-                enum=enum, primitive=primitive, bit_length=bit_length, **field_kwargs
+                enum=enum,  # type: ignore[arg-type]
+                primitive=primitive,
+                bit_length=bit_length,
+                **field_kwargs,
             )
 
         if issubclass(primitive, float):
@@ -664,35 +667,14 @@ def formfield(self, form_class=None, choices_form_class=None, **kwargs):
         #   we try to pass in. Very annoying because we have to
         #   un-encapsulate some of this initialization logic, this makes our
         #   EnumChoiceField pretty ugly!
-        from django_enum.forms import (
-            EnumChoiceField,
-            EnumFlagField,
-            FlagSelectMultiple,
-            NonStrictSelect,
-            NonStrictSelectMultiple,
-        )
-
-        is_multi = self.enum and issubclass(self.enum, Flag)
-        if is_multi:
-            kwargs["empty_value"] = None if self.null else self.enum(0)
-            # why fail? - does this fail for single select too?
-            # kwargs['show_hidden_initial'] = True
+        from django_enum.forms import EnumChoiceField, NonStrictSelect
 
         if not self.strict:
-            kwargs.setdefault(
-                "widget",
-                NonStrictSelectMultiple(enum=self.enum)
-                if is_multi
-                else NonStrictSelect,
-            )
-        elif is_multi:
-            kwargs.setdefault("widget", FlagSelectMultiple(enum=self.enum))
+            kwargs.setdefault("widget", NonStrictSelect)
 
         form_field = super().formfield(
             form_class=form_class,
-            choices_form_class=(
-                choices_form_class or EnumFlagField if is_multi else EnumChoiceField
-            ),
+            choices_form_class=choices_form_class or EnumChoiceField,
             **kwargs,
         )
 
@@ -709,8 +691,6 @@ def get_choices(
         limit_choices_to=None,
         ordering=(),
     ):
-        if self.enum and issubclass(self.enum, Flag):
-            blank_choice = [(self.enum(0), "---------")]
         return [
             (getattr(choice, "value", choice), label)
             for choice, label in super().get_choices(
@@ -1146,7 +1126,18 @@ class FlagField(with_typehint(IntEnumField)):  # type: ignore
     support bitwise operations.
     """
 
-    enum: Type[Flag]
+    enum: Type[IntFlag]
+
+    def __init__(
+        self,
+        enum: Optional[Type[IntFlag]] = None,
+        blank=True,
+        default=NOT_PROVIDED,
+        **kwargs,
+    ):
+        if enum and default is NOT_PROVIDED:
+            default = enum(0)
+        super().__init__(enum=enum, default=default, blank=blank, **kwargs)
 
     def contribute_to_class(
         self, cls: Type[Model], name: str, private_only: bool = False
@@ -1220,6 +1211,53 @@ def contribute_to_class(
             # for non flag fields
             IntegerField.contribute_to_class(self, cls, name, private_only=private_only)
 
+    def formfield(self, form_class=None, choices_form_class=None, **kwargs):
+        from django_enum.forms import (
+            ChoiceFieldMixin,
+            EnumFlagField,
+            FlagSelectMultiple,
+            NonStrictSelectMultiple,
+        )
+
+        kwargs["empty_value"] = None if self.default is None else self.enum(0)
+        kwargs.setdefault(
+            "widget",
+            FlagSelectMultiple(enum=self.enum)
+            if self.strict
+            else NonStrictSelectMultiple(enum=self.enum),
+        )
+
+        form_field = Field.formfield(
+            self,
+            form_class=form_class,
+            choices_form_class=choices_form_class or EnumFlagField,
+            **kwargs,
+        )
+
+        # we can't pass these in kwargs because formfield() strips them out
+        if isinstance(form_field, ChoiceFieldMixin):
+            form_field.enum = self.enum
+            form_field.strict = self.strict
+            form_field.primitive = self.primitive
+        return form_field
+
+    def get_choices(
+        self,
+        include_blank=False,
+        blank_choice=tuple(BLANK_CHOICE_DASH),
+        limit_choices_to=None,
+        ordering=(),
+    ):
+        return [
+            (getattr(choice, "value", choice), label)
+            for choice, label in super().get_choices(
+                include_blank=False,
+                blank_choice=blank_choice,
+                limit_choices_to=limit_choices_to,
+                ordering=ordering,
+            )
+        ]
+
 
 class SmallIntegerFlagField(FlagField, EnumPositiveSmallIntegerField):
     """

src/django_enum/forms.py

@@ -1,6 +1,5 @@
 """Enumeration support for django model forms"""
 
-import sys
 from copy import copy
 from decimal import DecimalException
 from enum import Enum, Flag
@@ -17,7 +16,12 @@
 from django.forms.widgets import Select, SelectMultiple
 
 from django_enum.utils import choices as get_choices
-from django_enum.utils import determine_primitive, with_typehint
+from django_enum.utils import (
+    decompose,
+    determine_primitive,
+    get_set_values,
+    with_typehint,
+)
 
 __all__ = [
     "NonStrictSelect",
@@ -98,25 +102,18 @@ def format_value(self, value):
         """
         Return a list of the flag's values.
         """
+        if value is None:
+            return []
         if not isinstance(value, list):
             # see impl of ChoiceWidget.optgroups
             # it compares the string conversion of the value of each
             # choice tuple to the string conversion of the value
             # to determine selected options
             if self.enum:
-                if sys.version_info < (3, 11):
-                    return [
-                        str(flg.value)
-                        for flg in self.enum
-                        if flg in self.enum(value) and flg is not self.enum(0)
-                    ]
-                else:
-                    return [str(en.value) for en in self.enum(value)]
+                return [str(en.value) for en in decompose(self.enum(value))]
             if isinstance(value, int):
                 # automagically work for IntFlags even if we weren't given the enum
-                return [
-                    str(1 << i) for i in range(value.bit_length()) if (value >> i) & 1
-                ]
+                return [str(bit) for bit in get_set_values(value)]
         return value
 
 

src/django_enum/utils.py

@@ -1,8 +1,9 @@
 """Utility routines for django_enum."""
 
+import sys
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
-from enum import Enum, IntFlag
+from enum import Enum, Flag, IntFlag
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
 
 from typing_extensions import get_args
@@ -21,6 +22,7 @@
 
 
 T = TypeVar("T")
+F = TypeVar("F", bound=Flag)
 
 SupportedPrimitive = Union[
     int,
@@ -214,11 +216,40 @@ def decimal_params(
     return {"max_digits": max_digits, "decimal_places": decimal_places}
 
 
-def get_set_bits(flag: Union[int, IntFlag]) -> List[int]:
+def get_set_bits(flag: Optional[Union[int, IntFlag]]) -> List[int]:
     """
     Return the indices of the bits set in the flag.
 
     :param flag: The flag to get the set bits for, value must be an int.
     :return: A list of indices of the set bits
     """
-    return [i for i in range(flag.bit_length()) if flag & (1 << i)]
+    if flag:
+        return [i for i in range(flag.bit_length()) if flag & (1 << i)]
+    return []
+
+
+def get_set_values(flag: Optional[Union[int, IntFlag]]) -> List[int]:
+    """
+    Return the integers corresponding to the flags set on the IntFlag or integer.
+
+    :param flag: The flag to get the set bits for, value must be an int.
+    :return: A list of flag integers
+    """
+    if flag:
+        return [1 << i for i in range(flag.bit_length()) if (flag >> i) & 1]
+    return []
+
+
+def decompose(flags: Optional[F]) -> List[F]:
+    """
+    Get the activated flags in a :class:`~enum.Flag` instance.
+
+    :param: flags: The flag instance to decompose
+    :return: A list of the :class:`~enum.Flag` instances comprising the flag.
+    """
+    if not flags:
+        return []
+    if sys.version_info < (3, 11):
+        return [flg for flg in type(flags) if flg in flags and flg is not flags(0)]
+    else:
+        return list(flags)  # type: ignore[arg-type]

tests/djenum/admin.py

@@ -1,8 +1,18 @@
 from django.contrib import admin
 
-from tests.djenum.models import AdminDisplayBug35, EnumTester
+from django.forms import ModelForm
+from tests.djenum.models import (
+    AdminDisplayBug35,
+    EnumTester,
+    NullBlankFormTester,
+    NullableBlankFormTester,
+    Bug53Tester,
+)
 
 admin.site.register(EnumTester)
+admin.site.register(NullBlankFormTester)
+admin.site.register(NullableBlankFormTester)
+admin.site.register(Bug53Tester)
 
 
 class AdminDisplayBug35Admin(admin.ModelAdmin):

tests/djenum/enums.py

@@ -47,6 +47,21 @@ def __str__(self):
         return self.name
 
 
+class NullableExternEnum(Enum):
+    """
+    Tests that externally defined (i.e. not deriving from choices enums
+    are supported.
+    """
+
+    NONE = None
+    ONE = 1
+    TWO = 2
+    THREE = 3
+
+    def __str__(self):
+        return self.name
+
+
 class Constants(FloatChoices):
     PI = 3.14159265358979323846264338327950288, "Pi"
     e = 2.71828, "Euler's Number"
@@ -357,3 +372,12 @@ class StrPropsEnum(Enum):
     STR1 = StrProps("str1")
     STR2 = StrProps("str2")
     STR3 = StrProps("str3")
+
+
+class StrTestEnum(str, Enum):
+    V1 = "v1"
+    V2 = "v2"
+    V3 = "v3"
+
+    def __str__(self):
+        return self.value