aenum - Advanced Enumerations

3.1.17 · active · verified Sat Mar 28

aenum is a Python library providing advanced enumerations that are compatible with Python's standard library Enum, along with metaclass-based NamedTuple and NamedConstant implementations. It offers extended features over the built-in `enum` module, such as support for unique values, multiple values, auto-numbering, and control over aliasing. The current version is 3.1.17 and it maintains an active release cadence.

Warnings

breaking Version 3.1 introduced breaking changes, including the removal of `AutoNumber` and `AutoValue`. Custom Enum settings relying on these features will need to be updated.
Fix: Migrate away from `AutoNumber` and `AutoValue`. Consider using `aenum.auto()` or manual value assignment.
gotcha When migrating from Python 2 to Python 3, code using `aenum` (or `enum34`) might require special handling for `__order__` in Python 2 to preserve member order, a detail that differs in Python 3.
Fix: Ensure `__order__` is correctly defined for Enums in Python 2 if explicit ordering is required, or rely on natural definition order in Python 3. Consider modernizing to Python 3 exclusively where possible.
gotcha By default, Enum members evaluate to `True` in a boolean context, even if their assigned value is `0`. This differs from standard Python integers where `0` is `False`. If this behavior is undesired, the `__bool__` (Python 3) or `__nonzero__` (Python 2) method must be overridden within the Enum.
Fix: Explicitly check `member.value` for its numeric truthiness, or override `__bool__` if the Enum member itself should reflect the truthiness of its value.
gotcha Python 3.11 introduced changes to `enum` mixin class behavior, particularly affecting how `__init__` and `__new__` interact with mixed-in data types, which could lead to unexpected value types for enum members. While some of these changes were later reverted, they represent a potential area of inconsistency when mixing types in Enums with `aenum` on newer Python versions.
Fix: Carefully test Enums that use mixed-in types when upgrading to Python 3.11 or later. Consult the `enum` module's documentation for Python 3.11+ regarding `__new__` and `__init__` behavior with mixins if encountering issues.

Install

pip install aenum Install aenum

Imports

Enum
```
from aenum import Enum
```
IntEnum
```
from aenum import IntEnum
```
Flag
```
from aenum import Flag
```
NamedTuple
```
from aenum import NamedTuple
```
NamedConstant
```
from aenum import NamedConstant
```
Enum
```
from aenum import Enum
```
Use `from aenum import Enum` to access aenum's extended features. Importing from the standard library `enum` module provides a different implementation without aenum's enhancements.

Quickstart

Demonstrates defining a basic Enum with auto-numbering and a simple NamedTuple.

from aenum import Enum, auto

class Color(Enum):
    RED = auto()
    GREEN = auto()
    BLUE = auto()

print(Color.RED) # Output: <Color.RED: 1>
print(Color.GREEN.value) # Output: 2

class MyNamedTuple(NamedTuple):
    field_a: int
    field_b: str

item = MyNamedTuple(1, 'hello')
print(item.field_a) # Output: 1

view raw JSON →