fully test django-filters integration and resolve a few minor issues

Author: bckohan

src/django_enum/filters.py

@@ -138,23 +138,28 @@ def __init__(
         **kwargs,
     ):
         self.enum = enum
-        self.lookup_expr = "has_all" if conjoined else "has_any"
         super().__init__(
             enum=enum,
             choices=kwargs.pop("choices", choices(self.enum)),
             strict=strict,
             conjoined=conjoined,
             **kwargs,
         )
+        self.lookup_expr = "has_all" if conjoined else "has_any"
 
     def filter(self, qs, value):
+        if value in {None, ""} or self.is_noop(qs, value):
+            return qs
+
         if value == self.null_value:
-            value = None
+            return self.get_method(qs)(Q(**{f"{self.field_name}__isnull": True}))
 
+        # special case of no activate flags, performs an exact lookup
+        # the form cleans unsupplied fields into 0s so we make sure this was supplied
+        # before filtering on it
         if not value:
-            return qs
-
-        if self.is_noop(qs, value):
+            if not self.parent or self.field_name in self.parent.form.data:
+                return self.get_method(qs)(Q(**{f"{self.field_name}": 0}))
             return qs
 
         qs = self.get_method(qs)(Q(**self.get_filter_predicate(value)))

src/django_enum/forms.py

@@ -155,10 +155,17 @@ def format_value(self, value):
             # choice tuple to the string conversion of the value
             # to determine selected options
             if self.enum:
-                return [str(en.value) for en in decompose(self.enum(value))]
+                named = [str(en.value) for en in decompose(self.enum(value))]
+                named_set = set(named)
+                unnamed = [
+                    str(val)
+                    for val in get_set_values(value)
+                    if str(val) not in named_set
+                ]
+                return [*named, *unnamed]
             if isinstance(value, int):
                 # automagically work for IntFlags even if we weren't given the enum
-                return [str(bit) for bit in get_set_values(value)]
+                return [str(val) for val in get_set_values(value)]
         return value
 
 
@@ -483,7 +490,9 @@ def _coerce(self, value: t.Any) -> t.Any:
         """Combine the values into a single flag using |"""
         if self.enum and isinstance(value, self.enum):
             return value
-        values = TypedMultipleChoiceField._coerce(self, value)  # type: ignore[attr-defined]
+        values = TypedMultipleChoiceField._coerce(  # type: ignore[attr-defined]
+            self, [value] if value and not isinstance(value, list) else value
+        )
         if values:
             return reduce(or_, values)
         return self.empty_value

tests/djenum/models.py

@@ -395,3 +395,14 @@ class AltWidgetTester(models.Model):
         GNSSConstellation, null=True, blank=True, default=None
     )
     constellation_non_strict = EnumField(GNSSConstellation, strict=False)
+
+
+class FlagFilterTester(models.Model):
+    small_flag = EnumField(enum=SmallPositiveFlagEnum, null=True, default=None)
+    flag = EnumField(enum=PositiveFlagEnum)
+    flag_no_coerce = EnumField(enum=PositiveFlagEnum, coerce=False)
+    big_flag = EnumField(enum=BigPositiveFlagEnum, strict=False)
+    # extra_big_flag = EnumField(enum=ExtraBigPositiveFlagEnum)
+
+    def get_absolute_url(self):
+        return reverse("tests_djenum:flag-detail", kwargs={"pk": self.pk})

tests/djenum/urls.py

@@ -7,6 +7,11 @@
     EnumTesterDetailView,
     EnumTesterListView,
     EnumTesterUpdateView,
+    FlagTesterCreateView,
+    FlagTesterDeleteView,
+    FlagTesterDetailView,
+    FlagTesterListView,
+    FlagTesterUpdateView,
 )
 
 app_name = "tests_djenum"
@@ -18,6 +23,11 @@
     path("enum/add/", EnumTesterCreateView.as_view(), name="enum-add"),
     path("enum/<int:pk>/", EnumTesterUpdateView.as_view(), name="enum-update"),
     path("enum/<int:pk>/delete/", EnumTesterDeleteView.as_view(), name="enum-delete"),
+    path("flag/<int:pk>", FlagTesterDetailView.as_view(), name="flag-detail"),
+    path("flag/list/", FlagTesterListView.as_view(), name="flag-list"),
+    path("flag/add/", FlagTesterCreateView.as_view(), name="flag-add"),
+    path("flag/<int:pk>/", FlagTesterUpdateView.as_view(), name="flag-update"),
+    path("flag/<int:pk>/delete/", FlagTesterDeleteView.as_view(), name="flag-delete"),
 ]
 
 
@@ -42,6 +52,10 @@
         EnumTesterFilterExcludeViewSet,
         EnumTesterMultipleFilterViewSet,
         EnumTesterMultipleFilterExcludeViewSet,
+        FlagTesterFilterViewSet,
+        FlagTesterFilterExcludeViewSet,
+        FlagTesterFilterConjoinedViewSet,
+        FlagTesterFilterConjoinedExcludeViewSet,
     )
 
     urlpatterns.extend(
@@ -75,6 +89,22 @@
                 EnumTesterMultipleFilterExcludeViewSet.as_view(),
                 name="enum-filter-multiple-exclude",
             ),
+            path("flag/filter/", FlagTesterFilterViewSet.as_view(), name="flag-filter"),
+            path(
+                "flag/filter/exclude",
+                FlagTesterFilterExcludeViewSet.as_view(),
+                name="flag-filter-exclude",
+            ),
+            path(
+                "flag/filter/conjoined",
+                FlagTesterFilterConjoinedViewSet.as_view(),
+                name="flag-filter-conjoined",
+            ),
+            path(
+                "flag/filter/conjoined/exclude",
+                FlagTesterFilterConjoinedExcludeViewSet.as_view(),
+                name="flag-filter-conjoined-exclude",
+            ),
         ]
     )
 except ImportError:  # pragma: no cover

tests/djenum/views.py

@@ -3,8 +3,9 @@
 from django.views.generic.edit import CreateView, DeleteView, UpdateView
 
 from django_enum import EnumField
+from django_enum.fields import FlagField
 from tests.djenum import enums as dj_enums
-from tests.djenum.models import EnumTester
+from tests.djenum.models import EnumTester, FlagFilterTester
 
 
 class URLMixin:
@@ -36,6 +37,22 @@ def get_context_data(self, **kwargs):
         }
 
 
+class FlagURLMixin:
+    NAMESPACE = "tests_djenum"
+    enums = dj_enums
+
+    def get_context_data(self, **kwargs):
+        return {
+            **super().get_context_data(**kwargs),
+            "SmallPositiveFlagEnum": self.enums.SmallPositiveFlagEnum,
+            "PositiveFlagEnum": self.enums.PositiveFlagEnum,
+            "BigPositiveFlagEnum": self.enums.BigPositiveFlagEnum,
+            "NAMESPACE": self.NAMESPACE,
+            "update_path": f"{self.NAMESPACE}:flag-update",
+            "delete_path": f"{self.NAMESPACE}:flag-delete",
+        }
+
+
 class EnumTesterDetailView(URLMixin, DetailView):
     model = EnumTester
     template_name = "enumtester_detail.html"
@@ -74,6 +91,44 @@ def get_success_url(self):  # pragma: no cover
         return reverse(f"{self.NAMESPACE}:enum-list")
 
 
+class FlagTesterDetailView(FlagURLMixin, DetailView):
+    model = FlagFilterTester
+    template_name = "flagtester_detail.html"
+    fields = "__all__"
+
+
+class FlagTesterListView(FlagURLMixin, ListView):
+    model = FlagFilterTester
+    template_name = "flagtester_list.html"
+    fields = "__all__"
+
+
+class FlagTesterCreateView(FlagURLMixin, CreateView):
+    model = FlagFilterTester
+    template_name = "flagtester_form.html"
+    fields = "__all__"
+
+    def post(self, request, *args, **kwargs):
+        return super().post(request, *args, **kwargs)
+
+
+class FlagTesterUpdateView(FlagURLMixin, UpdateView):
+    model = FlagFilterTester
+    template_name = "flagtester_form.html"
+    fields = "__all__"
+
+    def get_success_url(self):  # pragma: no cover
+        return reverse(f"{self.NAMESPACE}:flag-update", kwargs={"pk": self.object.pk})
+
+
+class FlagTesterDeleteView(FlagURLMixin, DeleteView):
+    model = FlagFilterTester
+    template_name = "flagtester_form.html"
+
+    def get_success_url(self):  # pragma: no cover
+        return reverse(f"{self.NAMESPACE}:flag-list")
+
+
 try:
     from rest_framework import serializers, viewsets
 
@@ -98,6 +153,7 @@ class DRFView(viewsets.ModelViewSet):
     from django_enum.filters import (
         FilterSet as EnumFilterSet,
         EnumFilter,
+        EnumFlagFilter,
         MultipleEnumFilter,
     )
 
@@ -254,5 +310,63 @@ class Meta:
         model = EnumTester
         template_name = "enumtester_list.html"
 
+    class FlagTesterFilterViewSet(FlagURLMixin, FilterView):
+        class FlagTesterFilter(EnumFilterSet):
+            class Meta:
+                model = FlagFilterTester
+                fields = "__all__"
+
+        filterset_class = FlagTesterFilter
+        model = FlagFilterTester
+        template_name = "flagtester_list.html"
+
+    class FlagTesterFilterExcludeViewSet(FlagURLMixin, FilterView):
+        class FlagTesterExcludeFilter(EnumFilterSet):
+            class Meta:
+                model = FlagFilterTester
+                fields = "__all__"
+                filter_overrides = {
+                    FlagField: {
+                        "filter_class": EnumFlagFilter,
+                        "extra": lambda f: {"exclude": True},
+                    }
+                }
+
+        filterset_class = FlagTesterExcludeFilter
+        model = FlagFilterTester
+        template_name = "flagtester_list.html"
+
+    class FlagTesterFilterConjoinedViewSet(FlagURLMixin, FilterView):
+        class FlagTesterConjoinedFilter(EnumFilterSet):
+            class Meta:
+                model = FlagFilterTester
+                fields = "__all__"
+                filter_overrides = {
+                    FlagField: {
+                        "filter_class": EnumFlagFilter,
+                        "extra": lambda f: {"conjoined": True},
+                    }
+                }
+
+        filterset_class = FlagTesterConjoinedFilter
+        model = FlagFilterTester
+        template_name = "flagtester_list.html"
+
+    class FlagTesterFilterConjoinedExcludeViewSet(FlagURLMixin, FilterView):
+        class FlagTesterConjoinedExcludeFilter(EnumFilterSet):
+            class Meta:
+                model = FlagFilterTester
+                fields = "__all__"
+                filter_overrides = {
+                    FlagField: {
+                        "filter_class": EnumFlagFilter,
+                        "extra": lambda f: {"exclude": True, "conjoined": True},
+                    }
+                }
+
+        filterset_class = FlagTesterConjoinedExcludeFilter
+        model = FlagFilterTester
+        template_name = "flagtester_list.html"
+
 except ImportError:  # pragma: no cover
     pass

tests/enum_prop/enums.py

@@ -346,35 +346,43 @@ class ExternEnum(IntEnumProperties):
 
 
 class SmallPositiveFlagEnum(FlagChoices):
-    ONE = 2**10, "One"
-    TWO = 2**11, "Two"
-    THREE = 2**12, "Three"
-    FOUR = 2**13, "Four"
-    FIVE = 2**14, "Five"
+    number: Annotated[int, Symmetric()]
+
+    ONE = 2**10, "One", 1
+    TWO = 2**11, "Two", 2
+    THREE = 2**12, "Three", 3
+    FOUR = 2**13, "Four", 4
+    FIVE = 2**14, "Five", 5
 
 
 class PositiveFlagEnum(FlagChoices):
-    ONE = 2**26, "One"
-    TWO = 2**27, "Two"
-    THREE = 2**28, "Three"
-    FOUR = 2**29, "Four"
-    FIVE = 2**30, "Five"
+    number: Annotated[int, Symmetric()]
+
+    ONE = 2**26, "One", 1
+    TWO = 2**27, "Two", 2
+    THREE = 2**28, "Three", 3
+    FOUR = 2**29, "Four", 4
+    FIVE = 2**30, "Five", 5
 
 
 class BigPositiveFlagEnum(FlagChoices):
-    ONE = 2**58, "One"
-    TWO = 2**59, "Two"
-    THREE = 2**60, "Three"
-    FOUR = 2**61, "Four"
-    FIVE = 2**62, "Five"
+    version: Annotated[float, Symmetric()]
+
+    ONE = 2**58, "One", 1.1
+    TWO = 2**59, "Two", 2.2
+    THREE = 2**60, "Three", 3.3
+    FOUR = 2**61, "Four", 4.4
+    FIVE = 2**62, "Five", 5.5
 
 
 class ExtraBigPositiveFlagEnum(FlagChoices):
-    ONE = 2**61, "One"
-    TWO = 2**62, "Two"
-    THREE = 2**63, "Three"
-    FOUR = 2**64, "Four"
-    FIVE = 2**65, "Five"
+    version: Annotated[float, Symmetric()]
+
+    ONE = 2**61, "One", 1.1
+    TWO = 2**62, "Two", 2.2
+    THREE = 2**63, "Three", 3.3
+    FOUR = 2**64, "Four", 4.4
+    FIVE = 2**65, "Five", 5.5
 
 
 class SmallNegativeFlagEnum(FlagChoices):

tests/enum_prop/models.py

@@ -458,3 +458,14 @@ class EnumFlagPropTesterRelated(BaseEnumFlagPropTester):
     related_flags = models.ManyToManyField(
         EnumFlagPropTester, related_name="related_flags"
     )
+
+
+class FlagFilterTester(models.Model):
+    small_flag = EnumField(enum=SmallPositiveFlagEnum, null=True, default=None)
+    flag = EnumField(enum=PositiveFlagEnum)
+    flag_no_coerce = EnumField(enum=PositiveFlagEnum, coerce=False)
+    big_flag = EnumField(enum=BigPositiveFlagEnum, strict=False)
+    # extra_big_flag = EnumField(enum=ExtraBigPositiveFlagEnum)
+
+    def get_absolute_url(self):
+        return reverse("tests_enum_prop:flag-detail", kwargs={"pk": self.pk})