closes #34

Author: bckohan

README.rst

@@ -43,6 +43,7 @@ was to:
 
 * Always automatically coerce fields to instances of the Enum type.
 * Allow strict adherence to Enum values to be disabled.
+* Be compatible with Enum classes that do not derive from Django's Choices.
 * Handle migrations appropriately. (See `migrations <https://django-enum.readthedocs.io/en/latest/usage.html#migrations>`_)
 * Integrate as fully as possible with Django_'s existing level of enum support.
 * Integrate with `enum-properties <https://pypi.org/project/enum-properties/>`_ to enable richer enumeration types.

django_enum/__init__.py

@@ -47,7 +47,7 @@
     'EnumFilter'
 ]
 
-VERSION = (1, 1, 2)
+VERSION = (1, 2, 0)
 
 __title__ = 'Django Enum'
 __version__ = '.'.join(str(i) for i in VERSION)

django_enum/choices.py

@@ -3,11 +3,86 @@
 types. These choices types are drop in replacements for the Django
 IntegerChoices and TextChoices.
 """
+from enum import Enum
+from typing import Any, List, Optional, Tuple, Type
+
 from django.db.models import Choices
 from django.db.models import IntegerChoices as DjangoIntegerChoices
 from django.db.models import TextChoices as DjangoTextChoices
 from django.db.models.enums import ChoicesMeta
 
+
+def choices(enum: Optional[Type[Enum]]) -> List[Tuple[Any, str]]:
+    """
+    Get the Django choices for an enumeration type. If the enum type has a
+    choices attribute, it will be used. Otherwise, the choices will be derived
+    from value, label pairs if the enumeration type has a label attribute, or
+    the name attribute if it does not.
+
+    This is used for compat with enums that do not inherit from Django's
+    Choices type.
+
+    :param enum: The enumeration type
+    :return: A list of (value, label) pairs
+    """
+    return getattr(
+        enum,
+        'choices', [
+            *([(None, enum.__empty__)] if hasattr(enum, '__empty__') else []),
+            *[
+                (
+                    member.value,
+                    getattr(member, 'label', getattr(member, 'name'))
+                )
+                for member in enum
+            ]
+        ]
+    ) if enum else []
+
+
+def names(enum: Optional[Type[Enum]]) -> List[Any]:
+    """
+    Return a list of names to use for the enumeration type. This is used
+    for compat with enums that do not inherit from Django's Choices type.
+
+    :param enum: The enumeration type
+    :return: A list of labels
+    """
+    return getattr(
+        enum,
+        'names', [
+            *(['__empty__'] if hasattr(enum, '__empty__') else []),
+            *[member.name for member in enum]
+        ]
+    ) if enum else []
+
+
+def labels(enum: Optional[Type[Enum]]) -> List[Any]:
+    """
+    Return a list of labels to use for the enumeration type. See choices.
+
+    This is used for compat with enums that do not inherit from Django's
+    Choices type.
+
+    :param enum: The enumeration type
+    :return: A list of labels
+    """
+    return getattr(enum, 'labels', [label for _, label in choices(enum)])
+
+
+def values(enum: Optional[Type[Enum]]) -> List[Any]:
+    """
+    Return a list of the values of an enumeration type.
+
+    This is used for compat with enums that do not inherit from Django's
+    Choices type.
+
+    :param enum: The enumeration type
+    :return: A list of values
+    """
+    return getattr(enum, 'values', [value for value, _ in choices(enum)])
+
+
 try:
     from enum_properties import EnumPropertiesMeta, SymmetricMixin
 
@@ -63,7 +138,6 @@ class FloatChoices(
         """
 
 except (ImportError, ModuleNotFoundError):
-    from enum import Enum
 
     # 3.11 - extend from Enum so base type check does not throw type error
     class MissingEnumProperties(Enum):

django_enum/drf.py

@@ -3,9 +3,10 @@
 __all__ = ['EnumField']
 
 try:
+    from enum import Enum
     from typing import Any, Type, Union
 
-    from django.db.models import Choices
+    from django_enum.choices import choices, values
     from rest_framework.fields import ChoiceField
 
     class EnumField(ChoiceField):
@@ -23,21 +24,21 @@ class EnumField(ChoiceField):
             will be passed up to the base classes.
         """
 
-        enum: Type[Choices]
+        enum: Type[Enum]
         strict: bool = True
 
         def __init__(
                 self,
-                enum: Type[Choices],
+                enum: Type[Enum],
                 strict: bool = strict,
                 **kwargs
         ):
             self.enum = enum
             self.strict = strict
-            self.choices = kwargs.pop('choices', enum.choices)
+            self.choices = kwargs.pop('choices', choices(enum))
             super().__init__(choices=self.choices, **kwargs)
 
-        def to_internal_value(self, data: Any) -> Union[Choices, Any]:
+        def to_internal_value(self, data: Any) -> Union[Enum, Any]:
             """
             Transform the *incoming* primitive data into an enum instance.
             """
@@ -49,12 +50,12 @@ def to_internal_value(self, data: Any) -> Union[Choices, Any]:
                     data = self.enum(data)
                 except (TypeError, ValueError):
                     try:
-                        data = type(self.enum.values[0])(data)
+                        data = type(values(self.enum)[0])(data)
                         data = self.enum(data)
                     except (TypeError, ValueError):
                         if self.strict or not isinstance(
                             data,
-                            type(self.enum.values[0])
+                            type(values(self.enum)[0])
                         ):
                             self.fail('invalid_choice', input=data)
             return data

django_enum/fields.py

@@ -1,6 +1,7 @@
 """
 Support for Django model fields built from enumeration types.
 """
+from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -16,7 +17,6 @@
 from django.db.models import (
     BigIntegerField,
     CharField,
-    Choices,
     Field,
     FloatField,
     IntegerField,
@@ -27,6 +27,7 @@
     SmallIntegerField,
 )
 from django.db.models.query_utils import DeferredAttribute
+from django_enum.choices import choices, values
 from django_enum.forms import EnumChoiceField, NonStrictSelect
 
 T = TypeVar('T')  # pylint: disable=C0103
@@ -79,25 +80,25 @@ class EnumMixin(
         field type.
     """
 
-    enum: Optional[Type[Choices]] = None
+    enum: Optional[Type[Enum]] = None
     strict: bool = True
     coerce: bool = True
 
     descriptor_class = ToPythonDeferredAttribute
 
-    def _coerce_to_value_type(self, value: Any) -> Choices:
+    def _coerce_to_value_type(self, value: Any) -> Enum:
         """Coerce the value to the enumerations value type"""
         # note if enum type is int and a floating point is passed we could get
         # situations like X.xxx == X - this is acceptable
         if self.enum:
-            return type(self.enum.values[0])(value)
+            return type(values(self.enum)[0])(value)
         # can't ever reach this - just here to make type checker happy
         return value  # pragma: no cover
 
     def __init__(
             self,
             *args,
-            enum: Optional[Type[Choices]] = None,
+            enum: Optional[Type[Enum]] = None,
             strict: bool = strict,
             coerce: bool = coerce,
             **kwargs
@@ -106,14 +107,14 @@ def __init__(
         self.strict = strict if enum else False
         self.coerce = coerce if enum else False
         if self.enum is not None:
-            kwargs.setdefault('choices', enum.choices if enum else [])
+            kwargs.setdefault('choices', choices(enum))
         super().__init__(*args, **kwargs)
 
     def _try_coerce(
             self,
             value: Any,
             force: bool = False
-    ) -> Union[Choices, Any]:
+    ) -> Union[Enum, Any]:
         """
         Attempt coercion of value to enumeration type instance, if unsuccessful
         and non-strict, coercion to enum's primitive type will be done,
@@ -130,15 +131,18 @@ def _try_coerce(
                 try:
                     value = self._coerce_to_value_type(value)
                     value = self.enum(value)
-                except (TypeError, ValueError) as err:
-                    if self.strict or not isinstance(
-                        value,
-                        type(self.enum.values[0])
-                    ):
-                        raise ValueError(
-                            f"'{value}' is not a valid {self.enum.__name__} "
-                            f"required by field {self.name}."
-                        ) from err
+                except (TypeError, ValueError):
+                    try:
+                        value = self.enum[value]
+                    except KeyError as err:
+                        if self.strict or not isinstance(
+                            value,
+                            type(values(self.enum)[0])
+                        ):
+                            raise ValueError(
+                                f"'{value}' is not a valid {self.enum.__name__} "
+                                f"required by field {self.name}."
+                            ) from err
         return value
 
     def deconstruct(self) -> Tuple[str, str, List, dict]:
@@ -159,7 +163,7 @@ def deconstruct(self) -> Tuple[str, str, List, dict]:
         """
         name, path, args, kwargs = super().deconstruct()
         if self.enum is not None:
-            kwargs['choices'] = self.enum.choices
+            kwargs['choices'] = choices(self.enum)
 
         if 'default' in kwargs:
             # ensure default in deconstructed fields is always the primitive
@@ -216,7 +220,7 @@ def from_db_value(
             return value
         return self._try_coerce(value)
 
-    def to_python(self, value: Any) -> Union[Choices, Any]:
+    def to_python(self, value: Any) -> Union[Enum, Any]:
         """
         Converts the value in the enumeration type.
 
@@ -301,10 +305,12 @@ class EnumCharField(EnumMixin, CharField):
     """
 
     def __init__(self, *args, enum=None, **kwargs):
-        choices = kwargs.get('choices', enum.choices if enum else [])
         kwargs.setdefault(
             'max_length',
-            max((len(choice[0]) for choice in choices))
+            max((
+                len(choice[0])
+                for choice in kwargs.get('choices', choices(enum))
+            ))
         )
         super().__init__(*args, enum=enum, **kwargs)
 
@@ -361,7 +367,7 @@ class _EnumFieldMetaClass(type):
 
     def __new__(  # pylint: disable=R0911
             mcs,
-            enum: Type[Choices]
+            enum: Type[Enum]
     ) -> Type[EnumMixin]:
         """
         Construct a new Django Field class given the Enumeration class. The
@@ -370,23 +376,21 @@ def __new__(  # pylint: disable=R0911
 
         :param enum: The class of the Enumeration to build a field class for
         """
-        assert issubclass(enum, Choices), \
-            f'{enum} must inherit from {Choices}!'
         primitives = mcs.SUPPORTED_PRIMITIVES.intersection(set(enum.__mro__))
-        assert len(primitives) == 1, f'{enum} must inherit from exactly one ' \
-                                     f'supported primitive type ' \
-                                     f'{mcs.SUPPORTED_PRIMITIVES}, ' \
-                                     f'encountered: {primitives}.'
-
-        primitive = list(primitives)[0]
+        primitive = (
+            list(primitives)[0] if primitives else type(values(enum)[0])
+        )
+        assert primitive in mcs.SUPPORTED_PRIMITIVES, \
+            f'Enum {enum} has values of an unnsupported primitive type: ' \
+            f'{primitive}'
 
         if primitive is float:
             return EnumFloatField
 
         if primitive is int:
-            values = [define.value for define in enum]
-            min_value = min(values)
-            max_value = max(values)
+            vals = [define.value for define in enum]
+            min_value = min(vals)
+            max_value = max(vals)
             if min_value < 0:
                 if min_value < -2147483648 or max_value > 2147483647:
                     return EnumBigIntegerField
@@ -404,7 +408,7 @@ def __new__(  # pylint: disable=R0911
 
 
 def EnumField(  # pylint: disable=C0103
-        enum: Type[Choices],
+        enum: Type[Enum],
         *field_args,
         **field_kwargs
 ) -> EnumMixin:

django_enum/filters.py

@@ -4,6 +4,7 @@
 
 from django.db.models import Field as ModelField
 from django.forms.fields import Field as FormField
+from django_enum.choices import choices
 from django_enum.forms import EnumChoiceField
 
 try:
@@ -43,7 +44,7 @@ def __init__(self, *, enum, strict=False, **kwargs):
             self.enum = enum
             super().__init__(
                 enum=enum,
-                choices=kwargs.pop('choices', self.enum.choices),
+                choices=kwargs.pop('choices', choices(self.enum)),
                 strict=strict,
                 **kwargs
             )
@@ -61,7 +62,7 @@ def filter_for_lookup(
                 lookup_type: str
         ) -> Tuple[Type[Filter], dict]:
             """For EnumFields use the EnumFilter class by default"""
-            if hasattr(field, 'enum') and hasattr(field.enum, 'choices'):
+            if hasattr(field, 'enum'):
                 return EnumFilter, {
                     'enum': field.enum,
                     'strict': getattr(field, 'strict', False)