fix #25

Author: bckohan

doc/source/changelog.rst

@@ -4,7 +4,7 @@
 Change Log
 ==========
 
-v2.2.0 (2025-03-XX)
+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>`_
@@ -18,7 +18,8 @@ v2.2.0 (2025-03-XX)
 * Implemented `Upgrade to enum-properties >=2.2 <https://github.com/bckohan/django-enum/issues/95>`_
 * Implemented `Move form imports to locally scoped imports where needed in fields.py <https://github.com/bckohan/django-enum/issues/79>`_
 * Implemented `Reorganize documentation using diataxis <https://github.com/bckohan/django-enum/issues/72>`_
-* Implemented `Provide an EnumMultipleChoiceField <https://github.com/bckohan/django-enum/issues/72>`_
+* Implemented `Provide a MultipleEnumChoiceFilter <https://github.com/bckohan/django-enum/issues/25>`_
+* Implemented `Provide an EnumMultipleChoiceField <https://github.com/bckohan/django-enum/issues/24>`_
 
 v2.1.0 (2025-02-24)
 ===================

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,
-            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),
+            else FlagNonStrictSelectMultiple(enum=self.enum),
         )
 
         form_field = Field.formfield(

src/django_enum/filters.py

@@ -2,14 +2,27 @@
 Support for :doc:`django-filter <django-filter:index>`.
 """
 
-from typing import Tuple, Type
+import typing as t
+from enum import Enum
 
 from django.db.models import Field as ModelField
-from django_filters import Filter, TypedChoiceFilter, filterset
-
-from django_enum.forms import EnumChoiceField
+from django_filters import (
+    Filter,
+    TypedChoiceFilter,
+    TypedMultipleChoiceFilter,
+    filterset,
+)
+
+from django_enum.fields import EnumField
+from django_enum.forms import EnumChoiceField, EnumMultipleChoiceField
 from django_enum.utils import choices
 
+__all__ = [
+    "EnumFilter",
+    "MultipleEnumFilter",
+    "FilterSet",
+]
+
 
 class EnumFilter(TypedChoiceFilter):
     """
@@ -44,9 +57,37 @@ class Color(TextChoices):
     :param kwargs: Any additional arguments for base classes
     """
 
+    enum: t.Type[Enum]
     field_class = EnumChoiceField
 
-    def __init__(self, *, enum, strict=False, **kwargs):
+    def __init__(self, *, enum: t.Type[Enum], strict: bool = False, **kwargs):
+        self.enum = enum
+        super().__init__(
+            enum=enum,
+            choices=kwargs.pop("choices", choices(self.enum)),
+            strict=strict,
+            **kwargs,
+        )
+
+
+class MultipleEnumFilter(TypedMultipleChoiceFilter):
+    """
+    Use this filter class instead of
+    :ref:`MultipleChoiceFilter <django-filter:multiple-choice-filter>`
+    to get filters to accept multiple :class:`~enum.Enum` labels and symmetric
+    properties.
+
+    :param enum: The class of the enumeration containing the values to
+        filter on
+    :param strict: If False (default), values not in the enumeration will
+        be searchable.
+    :param kwargs: Any additional arguments for base classes
+    """
+
+    enum: t.Type[Enum]
+    field_class = EnumMultipleChoiceField
+
+    def __init__(self, *, enum: t.Type[Enum], strict: bool = False, **kwargs):
         self.enum = enum
         super().__init__(
             enum=enum,
@@ -68,9 +109,9 @@ class FilterSet(filterset.FilterSet):
     @classmethod
     def filter_for_lookup(
         cls, field: ModelField, lookup_type: str
-    ) -> Tuple[Type[Filter], dict]:
+    ) -> t.Tuple[t.Optional[t.Type[Filter]], t.Dict[str, t.Any]]:
         """For EnumFields use the EnumFilter class by default"""
-        if hasattr(field, "enum"):
+        if isinstance(field, EnumField):
             return EnumFilter, {
                 "enum": field.enum,
                 "strict": getattr(field, "strict", False),

src/django_enum/forms.py

@@ -13,7 +13,7 @@
     TypedChoiceField,
     TypedMultipleChoiceField,
 )
-from django.forms.widgets import Select, SelectMultiple
+from django.forms.widgets import ChoiceWidget, Select, SelectMultiple
 
 from django_enum.utils import choices as get_choices
 from django_enum.utils import (
@@ -27,6 +27,7 @@
     "NonStrictSelect",
     "NonStrictSelectMultiple",
     "FlagSelectMultiple",
+    "FlagNonStrictSelectMultiple",
     "ChoiceFieldMixin",
     "EnumChoiceField",
     "EnumMultipleChoiceField",
@@ -118,7 +119,14 @@ def format_value(self, value):
         return value
 
 
-class NonStrictSelectMultiple(NonStrictMixin, FlagSelectMultiple):
+class NonStrictSelectMultiple(NonStrictMixin, SelectMultiple):
+    """
+    A SelectMultiple widget for non-strict EnumFlagFields that includes any
+    existing non-conforming value as a choice option.
+    """
+
+
+class FlagNonStrictSelectMultiple(NonStrictMixin, FlagSelectMultiple):
     """
     A SelectMultiple widget for non-strict EnumFlagFields that includes any
     existing non-conforming value as a choice option.
@@ -157,6 +165,8 @@ class ChoiceFieldMixin(
 
     choices: _ChoicesParameter
 
+    non_strict_widget: Type[ChoiceWidget] = NonStrictSelect
+
     def __init__(
         self,
         enum: Optional[Type[Enum]] = _enum_,
@@ -172,7 +182,7 @@ def __init__(
         self._strict_ = strict
         self._primitive_ = primitive
         if not self.strict:
-            kwargs.setdefault("widget", NonStrictSelect)
+            kwargs.setdefault("widget", self.non_strict_widget)
 
         if empty_values is _Unspecified:
             self.empty_values = copy(list(TypedChoiceField.empty_values))
@@ -323,7 +333,7 @@ def validate(self, value):
 
 class EnumChoiceField(ChoiceFieldMixin, TypedChoiceField):  # type: ignore
     """
-    The default :class:`~django.forms.fields.ChoiceField` will only accept the base
+    The default :class:`~django.forms.ChoiceField` will only accept the base
     enumeration values. Use this field on forms to accept any value mappable to an
     enumeration including any labels, symmetric properties, of values accepted in
     :meth:`~enum.Enum._missing_`.
@@ -334,20 +344,22 @@ class EnumMultipleChoiceField(  # type: ignore
     ChoiceFieldMixin, TypedMultipleChoiceField
 ):
     """
-    The default :class:`~django.forms.fields.MultipleChoiceField` will only accept the
+    The default :class:`~django.forms.MultipleChoiceField` will only accept the
     base enumeration values. Use this field on forms to accept multiple values mappable
     to an enumeration including any labels, symmetric properties, of values accepted in
     :meth:`~enum.Enum._missing_`.
     """
 
+    non_strict_widget = NonStrictSelectMultiple
+
 
 class EnumFlagField(ChoiceFieldMixin, TypedMultipleChoiceField):  # type: ignore
     """
     A generic form field for :class:`~enum.Flag` derived enumerations. By default the
     :class:`~django_enum.forms.FlagSelectMultiple` widget will be used.
 
-    After cleaning the value stored in the cleaned data will be a combined enum instance.
-    (e.g. all input flags will be or-ed together)
+    After cleaning the value stored in the cleaned data will be a combined enum
+    instance. (e.g. all input flags will be or-ed together)
 
     .. note::
 
@@ -356,6 +368,7 @@ class EnumFlagField(ChoiceFieldMixin, TypedMultipleChoiceField):  # type: ignore
     """
 
     widget = FlagSelectMultiple
+    non_strict_widget = FlagNonStrictSelectMultiple
 
     def __init__(
         self,
@@ -369,7 +382,7 @@ def __init__(
     ):
         kwargs.setdefault(
             "widget",
-            self.widget(enum=enum) if strict else NonStrictSelectMultiple(enum=enum),
+            self.widget(enum=enum) if strict else self.non_strict_widget(enum=enum),  # type: ignore[call-arg]
         )
         super().__init__(
             enum=enum,

tests/djenum/urls.py

@@ -37,7 +37,10 @@
 try:
     from django_filters.views import FilterView
 
-    from tests.djenum.views import EnumTesterFilterViewSet
+    from tests.djenum.views import (
+        EnumTesterFilterViewSet,
+        EnumTesterMultipleFilterViewSet,
+    )
 
     urlpatterns.extend(
         [
@@ -55,6 +58,11 @@
                 EnumTesterFilterViewSet.as_view(),
                 name="enum-filter-symmetric",
             ),
+            path(
+                "enum/filter/multiple/",
+                EnumTesterMultipleFilterViewSet.as_view(),
+                name="enum-filter-multiple",
+            ),
         ]
     )
 except ImportError:  # pragma: no cover

tests/djenum/views.py

@@ -95,7 +95,26 @@ class DRFView(viewsets.ModelViewSet):
 try:
     from django_filters.views import FilterView
 
-    from django_enum.filters import FilterSet as EnumFilterSet
+    from django_enum.filters import FilterSet as EnumFilterSet, MultipleEnumFilter
+
+    from .enums import (
+        BigIntEnum,
+        BigPosIntEnum,
+        Constants,
+        DateEnum,
+        DateTimeEnum,
+        DecimalEnum,
+        DJIntEnum,
+        DJTextEnum,
+        DurationEnum,
+        ExternEnum,
+        IntEnum,
+        PosIntEnum,
+        SmallIntEnum,
+        SmallPosIntEnum,
+        TextEnum,
+        TimeEnum,
+    )
 
     class EnumTesterFilterViewSet(URLMixin, FilterView):
         class EnumTesterFilter(EnumFilterSet):
@@ -107,5 +126,58 @@ class Meta:
         model = EnumTester
         template_name = "enumtester_list.html"
 
+    class EnumTesterMultipleFilterViewSet(URLMixin, FilterView):
+        class EnumTesterMultipleFilter(EnumFilterSet):
+            small_pos_int = MultipleEnumFilter(enum=SmallPosIntEnum)
+            small_int = MultipleEnumFilter(enum=SmallIntEnum)
+            pos_int = MultipleEnumFilter(enum=PosIntEnum)
+            int = MultipleEnumFilter(enum=IntEnum)
+            big_pos_int = MultipleEnumFilter(enum=BigPosIntEnum)
+            big_int = MultipleEnumFilter(enum=BigIntEnum)
+            constant = MultipleEnumFilter(enum=Constants)
+            text = MultipleEnumFilter(enum=TextEnum)
+            extern = MultipleEnumFilter(enum=ExternEnum)
+
+            dj_int_enum = MultipleEnumFilter(enum=DJIntEnum)
+            dj_text_enum = MultipleEnumFilter(enum=DJTextEnum)
+
+            # Non-strict
+            non_strict_int = MultipleEnumFilter(enum=SmallPosIntEnum, strict=False)
+            non_strict_text = MultipleEnumFilter(enum=TextEnum, strict=False)
+            no_coerce = MultipleEnumFilter(enum=SmallPosIntEnum, strict=False)
+
+            # eccentric enums
+            date_enum = MultipleEnumFilter(enum=DateEnum)
+            datetime_enum = MultipleEnumFilter(enum=DateTimeEnum)
+            time_enum = MultipleEnumFilter(enum=TimeEnum)
+            duration_enum = MultipleEnumFilter(enum=DurationEnum)
+            decimal_enum = MultipleEnumFilter(enum=DecimalEnum)
+
+            class Meta:
+                fields = [
+                    "small_pos_int",
+                    "small_int",
+                    "pos_int",
+                    "int",
+                    "big_pos_int",
+                    "big_int",
+                    "constant",
+                    "text",
+                    "extern",
+                    "non_strict_int",
+                    "non_strict_text",
+                    "no_coerce",
+                    "date_enum",
+                    "datetime_enum",
+                    "time_enum",
+                    "duration_enum",
+                    "decimal_enum",
+                ]
+                model = EnumTester
+
+        filterset_class = EnumTesterMultipleFilter
+        model = EnumTester
+        template_name = "enumtester_list.html"
+
 except ImportError:  # pragma: no cover
     pass

tests/enum_prop/urls.py

@@ -34,7 +34,10 @@
 try:
     from django_filters.views import FilterView
 
-    from tests.enum_prop.views import EnumTesterFilterViewSet
+    from tests.enum_prop.views import (
+        EnumTesterPropFilterViewSet,
+        EnumTesterPropMultipleFilterViewSet,
+    )
 
     urlpatterns.extend(
         [
@@ -49,9 +52,14 @@
             ),
             path(
                 "enum/filter/symmetric/",
-                EnumTesterFilterViewSet.as_view(),
+                EnumTesterPropFilterViewSet.as_view(),
                 name="enum-filter-symmetric",
             ),
+            path(
+                "enum/filter/multiple/",
+                EnumTesterPropMultipleFilterViewSet.as_view(),
+                name="enum-filter-multiple",
+            ),
         ]
     )
 except (ImportError, ModuleNotFoundError):  # pragma: no cover