fix choices resolution with and without aliases #118

Author: bckohan

doc/source/changelog.rst

@@ -4,7 +4,7 @@
 Change Log
 ==========
 
-v2.2.0 (2025-03-27)
+v2.2.0 (2025-03-28)
 ===================
 
 * Implemented `Need a DRF integration for FlagFields <https://github.com/bckohan/django-enum/issues/113>`_

pyproject.toml

@@ -61,7 +61,7 @@ packages = ["src/django_enum"]
 
 
 [project.optional-dependencies]
-properties = ["enum-properties>=2.2.0"]
+properties = ["enum-properties>=2.3.0"]
 filters = ["django-filter>=21"]
 rest = ["djangorestframework>=3.9,<4.0"]
 

src/django_enum/choices.py

@@ -33,6 +33,20 @@ class DjangoEnumPropertiesMeta(EnumPropertiesMeta, ChoicesType):  # type: ignore
     enum-properties' generic property support.
     """
 
+    def __new__(mcs, classname, bases, classdict, **kwargs):
+        cls = super().__new__(mcs, classname, bases, classdict, **kwargs)
+        # choices does not allow duplicates, but base class construction breaks
+        # this member, so we alias it here to stay compatible with enum-properties
+        # interface
+        # TODO - is this a fixable bug in ChoicesType?
+        cls._member_names_ = (
+            list(classdict._member_names.keys())
+            if isinstance(classdict._member_names, dict)  # changes based on py ver
+            else classdict._member_names
+        )
+        cls.__first_class_members__ = cls._member_names_
+        return cls
+
     @property
     def names(self) -> t.List[str]:
         """

src/django_enum/utils.py

@@ -4,7 +4,19 @@
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 from enum import Enum, Flag, IntFlag
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
+from importlib.util import find_spec
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
 
 from typing_extensions import get_args
 
@@ -20,10 +32,17 @@
     "get_set_values",
     "get_set_bits",
     "decompose",
+    "members",
 ]
 
 
+PROPERTIES_ENABLED = find_spec("enum_properties")
+"""
+True if enum-properties is installed, False otherwise.
+"""
+
 T = TypeVar("T")
+E = TypeVar("E", bound=Enum)
 F = TypeVar("F", bound=Flag)
 
 SupportedPrimitive = Union[
@@ -54,7 +73,7 @@ def with_typehint(baseclass: Type[T]) -> Type[T]:
 
 
 def choices(
-    enum_cls: Optional[Type[Enum]], override: bool = False
+    enum_cls: Optional[Type[Enum]], override: bool = False, aliases: bool = True
 ) -> List[Tuple[Any, str]]:
     """
     Get the Django choices for an enumeration type. If the enum type has a
@@ -67,6 +86,7 @@ def choices(
 
     :param enum_cls: The enumeration type
     :param override: Do not defer to choices attribute on the class if True
+    :param aliases: Include first-class aliases in the result if True (default: True)
     :return: A list of (value, label) pairs
     """
     return (
@@ -80,7 +100,7 @@ def choices(
                 ),
                 *[
                     (member.value, getattr(member, "label", getattr(member, "name")))
-                    for member in list(enum_cls) or enum_cls.__members__.values()
+                    for member in members(enum_cls, aliases=aliases)
                 ],
             ]
         )
@@ -89,24 +109,24 @@ def choices(
     )
 
 
-def names(enum_cls: Optional[Type[Enum]], override: bool = False) -> List[Any]:
+def names(
+    enum_cls: Optional[Type[Enum]], override: bool = False, aliases: bool = True
+) -> 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_cls: The enumeration type
     :param override: Do not defer to names attribute on the class if True
+    :param aliases: Include first-class aliases in the result if True (default: True)
     :return: A list of labels
     """
     return (
         (getattr(enum_cls, "names", []) if not override else [])
         or (
             [
                 *(["__empty__"] if hasattr(enum_cls, "__empty__") else []),
-                *[
-                    member.name
-                    for member in list(enum_cls) or enum_cls.__members__.values()
-                ],
+                *[member.name for member in members(enum_cls, aliases=aliases)],
             ]
         )
         if enum_cls
@@ -189,6 +209,16 @@ def determine_primitive(enum: Type[Enum]) -> Optional[Type]:
     return primitive
 
 
+def is_power_of_two(n: int) -> bool:
+    """
+    Check if an integer is a power of two.
+
+    :param n: The integer to check
+    :return: True if the number is a power of two, False otherwise
+    """
+    return n != 0 and (n & (n - 1)) == 0
+
+
 def decimal_params(
     enum: Optional[Type[Enum]],
     decimal_places: Optional[int] = None,
@@ -264,9 +294,49 @@ class Permissions(IntFlag):
     """
     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 type(flags)(0)
-        ]
+    return [
+        flg
+        for flg in type(flags).__members__.values()
+        if flg in flags and flg is not type(flags)(0)
+    ]
+
+
+def members(enum: Type[E], aliases: bool = True) -> Generator[E, None, None]:
+    """
+    Get the members of an enumeration class. This can be tricky to do
+    in a python version agnostic way, so it is recommended to
+    use this function.
+
+    .. note:
+
+        Composite flag values, such as `A | B` when named on a
+        :class:`~enum.IntFlag` class are considered aliases by this function.
+
+    :param enum_cls: The enumeration class
+    :param aliases: Include aliases in the result if True (default: True)
+    :return: A generator that yields the enumeration members
+    """
+    if aliases:
+        if PROPERTIES_ENABLED:
+            from enum_properties import SymmetricMixin
+
+            if issubclass(enum, SymmetricMixin):
+                for member in enum.__first_class_members__:
+                    yield enum[member]  # type: ignore[index]
+                return
+        yield from enum.__members__.values()
     else:
-        return list(flags)  # type: ignore[arg-type]
+        if issubclass(enum, Flag) and (
+            issubclass(enum, int)
+            or isinstance(next(iter(enum.__members__.values())).value, int)
+        ):
+            for name in enum._member_names_:
+                en = enum[name]
+                value = en.value
+                if value < 0 or is_power_of_two(value):
+                    yield en  # type: ignore[misc]
+        elif sys.version_info[:2] >= (3, 11):
+            yield from enum  # type: ignore[misc]
+        else:
+            for name in enum._member_names_:
+                yield enum[name]

tests/test_requests.py

@@ -1,5 +1,6 @@
 from importlib.util import find_spec
 import typing as t
+from enum import Enum
 from tests.utils import EnumTypeMixin, try_convert
 from django.test import TestCase
 from tests.djenum.models import EnumTester
@@ -562,6 +563,9 @@ def verify_form(self, obj, soup):
                         self.assertTrue(option.has_attr("selected"))
                     del expected[value]
                 except KeyError:  # pragma: no cover
+                    import ipdb
+
+                    ipdb.set_trace()
                     self.fail(
                         f"{field.name} did not expect option "
                         f"{option['value']}: {option.text}."