aenum - Advanced Enumerations

3.1.17 verified Tue May 12 auth: no python install: verified quickstart: stale

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.

pip install aenum

Common errors

error ModuleNotFoundError: No module named 'aenum' ↓

cause The 'aenum' module is not installed in the Python environment.

fix

Install the 'aenum' module using pip: 'pip install aenum'.

error TypeError: issubclass() arg 1 must be a class ↓

cause Incorrect usage of the 'Enum' class constructor with positional arguments instead of keyword arguments.

fix

Use the 'Enum' constructor with keyword arguments: 'Enum('EnumName', {'member1': value1, 'member2': value2})'.

error ValueError: 8 is not a valid DataType ↓

cause Attempting to retrieve an Enum member by value when the Enum members have list or tuple values.

fix

Use a custom method to search for the Enum member by iterating over the Enum members and checking if the value is in the member's value list.

error ModuleNotFoundError: No module named 'aenum._common' ↓

cause This error typically occurs due to an incomplete or corrupted `aenum` installation, often seen with specific versions (e.g., 3.1.13, 3.1.14) or when using PyPy, where internal modules like `_common` are not found.

fix

Upgrade aenum to the latest version to resolve packaging issues or compatibility fixes: pip install --upgrade aenum

error AttributeError: module 'aenum._common' has no attribute 'NoneType' ↓

cause This error indicates a compatibility issue with certain Python implementations (like PyPy) and specific `aenum` versions, where a required internal type `NoneType` is not correctly exposed or handled by the `aenum._common` module.

fix

Upgrade aenum to the latest stable version, as this specific issue was often resolved in subsequent releases: pip install --upgrade aenum

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.

gotcha A `NameError: name 'NamedTuple' is not defined` occurs when `NamedTuple` is referenced without being imported from the `typing` module. This is a common Python coding error, not specific to the `aenum` library. ↓

fix Ensure `NamedTuple` is imported from the `typing` module (e.g., `from typing import NamedTuple`) before use.

gotcha The `NamedTuple` class is not a built-in type and must be explicitly imported from the `typing` module (e.g., `from typing import NamedTuple`) before it can be used to define custom named tuple classes. ↓

fix Add `from typing import NamedTuple` at the top of the script or module where `NamedTuple` is being used.

Install compatibility verified last tested: 2026-05-12

python os / libc status wheel install import disk

3.10 alpine (musl) - - 0.06s 19.3M

3.10 slim (glibc) - - 0.04s 20M

3.11 alpine (musl) - - 0.10s 21.8M

3.11 slim (glibc) - - 0.07s 22M

3.12 alpine (musl) - - 0.07s 13.6M

3.12 slim (glibc) - - 0.08s 14M

3.13 alpine (musl) - - 0.07s 13.2M

3.13 slim (glibc) - - 0.09s 14M

3.9 alpine (musl) - - 0.05s 18.9M

3.9 slim (glibc) - - 0.04s 19M

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
wrong
```
from enum import Enum
```
correct
```
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 stale last tested: 2026-04-23

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