tessl/pypi-aenum

Advanced Enumerations (compatible with Python's stdlib Enum), NamedTuples, and NamedConstants

1.20x

Overview

Eval results

Files

Advanced Enum Features

Name: tessl/pypi-aenum
Rating: 0.76 (1 reviews)
Author: tessl

Specialized enumeration classes that provide automatic numbering, ordering, uniqueness constraints, and multi-value support for complex enumeration needs.

Capabilities

AutoNumberEnum

Enumeration that automatically assigns increasing integer values starting from 1. Useful when you need sequential numbering but don't want to manually specify values.

class AutoNumberEnum(Enum):
    def _generate_next_value_(name, start, count, last_values):
        """
        Generate the next value for auto-numbered enum members.
        
        Args:
            name (str): Name of the enum member being created
            start (int): Starting value (typically 1)
            count (int): Number of existing members
            last_values (list): List of values from existing members
            
        Returns:
            int: Next sequential value
        """

Usage Example

from aenum import AutoNumberEnum

class Priority(AutoNumberEnum):
    LOW      # Gets value 1
    MEDIUM   # Gets value 2  
    HIGH     # Gets value 3
    CRITICAL # Gets value 4

print(Priority.LOW.value)      # 1
print(Priority.CRITICAL.value) # 4

# Can mix with explicit values
class Status(AutoNumberEnum):
    PENDING    # Gets value 1
    ACTIVE = 10
    INACTIVE   # Gets value 11
    ARCHIVED   # Gets value 12

AutoEnum

Enumeration that automatically uses _generate_next_value_ when values are missing (Python 3 only). Similar to AutoNumberEnum but with enhanced auto-value generation.

class AutoEnum(Enum):
    """
    Auto-enum that uses _generate_next_value_ for missing values (Python 3 only).
    """

Usage Example

from aenum import AutoEnum

class Color(AutoEnum):
    def _generate_next_value_(name, start, count, last_values):
        return name.lower()
    
    RED     # Gets value 'red'
    GREEN   # Gets value 'green'
    BLUE    # Gets value 'blue'

print(Color.RED.value)  # 'red'

OrderedEnum

Enumeration that adds comparison operators (<, <=, >=, >) based on member values, enabling sorting and ordering of enum members.

class OrderedEnum(Enum):
    def __lt__(self, other):
        """Less than comparison based on value."""
    
    def __le__(self, other):
        """Less than or equal comparison based on value."""
    
    def __gt__(self, other):
        """Greater than comparison based on value."""
    
    def __ge__(self, other):
        """Greater than or equal comparison based on value."""

Usage Example

from aenum import OrderedEnum

class Size(OrderedEnum):
    SMALL = 1
    MEDIUM = 2
    LARGE = 3
    EXTRA_LARGE = 4

# Comparison operations
print(Size.SMALL < Size.LARGE)     # True
print(Size.MEDIUM >= Size.SMALL)   # True
print(max(Size.SMALL, Size.LARGE)) # Size.LARGE

# Sorting
sizes = [Size.LARGE, Size.SMALL, Size.MEDIUM]
sorted_sizes = sorted(sizes)
print(sorted_sizes)  # [Size.SMALL, Size.MEDIUM, Size.LARGE]

UniqueEnum

Enumeration that ensures all members have unique values, preventing accidental aliasing of enum members.

class UniqueEnum(Enum):
    """Enum that raises ValueError if duplicate values are found."""

Usage Example

from aenum import UniqueEnum

class Color(UniqueEnum):
    RED = 1
    GREEN = 2
    BLUE = 3
    # CRIMSON = 1  # Would raise ValueError: duplicate value found for 'CRIMSON': 1

# Alternative using @unique decorator
from aenum import Enum, unique

@unique
class Status(Enum):
    ACTIVE = 1
    INACTIVE = 2
    PENDING = 3
    # WAITING = 3  # Would raise ValueError

MultiValueEnum

Enumeration where each member can have multiple values, useful when one concept can be represented by several different values.

class MultiValueEnum(Enum):
    """Enum allowing members to have multiple values."""
    
    def __new__(cls, *values):
        """
        Create enum member with multiple values.
        
        Args:
            *values: Multiple values for this enum member
        """

Usage Example

from aenum import MultiValueEnum

class Color(MultiValueEnum):
    RED = 1, 'crimson', 'rouge', '#FF0000'
    GREEN = 2, 'lime', 'forest', '#00FF00'  
    BLUE = 3, 'navy', 'azure', '#0000FF'

# Access by any value
print(Color(1))         # Color.RED
print(Color('crimson')) # Color.RED  
print(Color('#FF0000')) # Color.RED

# Primary value is the first one
print(Color.RED.value)  # 1

# Access all values
print(Color.RED._value_)  # (1, 'crimson', 'rouge', '#FF0000')

AddValueEnum

Enumeration that uses _generate_next_value_ to prepend additional values to member definitions.

class AddValueEnum(Enum):
    def _generate_next_value_(name, start, count, last_values):
        """
        Generate additional values to prepend to member definition.
        
        Args:
            name (str): Name of the enum member
            start: Starting value
            count (int): Number of existing members
            last_values (list): Values from existing members
            
        Returns:
            Generated value to prepend
        """

Usage Example

from aenum import AddValueEnum

class Planet(AddValueEnum):
    def _generate_next_value_(name, start, count, last_values):
        # Generate ID based on count
        return count + 1
    
    # Format: generated_id, mass, radius
    MERCURY = 3.303e+23, 2.4397e6
    VENUS = 4.869e+24, 6.0518e6
    EARTH = 5.976e+24, 6.37814e6
    
    def __init__(self, planet_id, mass, radius):
        self.id = planet_id
        self.mass = mass
        self.radius = radius

print(Planet.EARTH.id)     # 3
print(Planet.EARTH.mass)   # 5.976e+24

NoAliasEnum

Enumeration where duplicate values create distinct members instead of aliases, useful when you need separate enum members with the same value.

class NoAliasEnum(Enum):
    """Enum where duplicate values create separate members."""

Usage Example

from aenum import NoAliasEnum

class HttpStatus(NoAliasEnum):
    OK = 200
    SUCCESS = 200  # Separate member, not an alias
    NOT_FOUND = 404
    ERROR = 404    # Separate member, not an alias

print(HttpStatus.OK)      # HttpStatus.OK
print(HttpStatus.SUCCESS) # HttpStatus.SUCCESS
print(HttpStatus.OK is HttpStatus.SUCCESS)  # False
print(HttpStatus.OK == HttpStatus.SUCCESS)  # True (same value)

Specialized String Enums

LowerStrEnum

String enumeration that automatically converts member names to lowercase values.

class LowerStrEnum(StrEnum):
    """StrEnum that uses lowercase member names as values."""

from aenum import LowerStrEnum

class Command(LowerStrEnum):
    START    # Value becomes 'start'
    STOP     # Value becomes 'stop'
    RESTART  # Value becomes 'restart'

print(Command.START)       # Command.START
print(Command.START.value) # 'start'
print(str(Command.START))  # 'start'

UpperStrEnum

String enumeration that automatically converts member names to uppercase values.

class UpperStrEnum(StrEnum):
    """StrEnum that uses uppercase member names as values."""

from aenum import UpperStrEnum

class LogLevel(UpperStrEnum):
    debug    # Value becomes 'DEBUG'
    info     # Value becomes 'INFO'
    warning  # Value becomes 'WARNING'
    error    # Value becomes 'ERROR'

print(LogLevel.debug.value)  # 'DEBUG'

Enum Settings

Configuration classes that modify enum behavior when used as base classes.

class AddValue:
    """Setting that prepends values from _generate_next_value_."""

class MagicValue:
    """Setting that calls _generate_next_value_ when no args given."""

class MultiValue:
    """Setting that allows members to have multiple values."""

class NoAlias:
    """Setting that prevents aliasing of duplicate values."""

class Unique:
    """Setting that requires all values to be unique."""

Usage Example

from aenum import Enum, AddValue, MultiValue, Unique

# Using settings as mixins
class ColorCode(Enum, MultiValue, Unique):
    RED = 1, '#FF0000', 'red'
    GREEN = 2, '#00FF00', 'green'
    BLUE = 3, '#0000FF', 'blue'
    # CRIMSON = 1, '#DC143C', 'crimson'  # Would raise ValueError (Unique)

print(ColorCode('red'))      # ColorCode.RED
print(ColorCode('#FF0000'))  # ColorCode.RED

Advanced Patterns

Custom Value Generation

from aenum import Enum

class TimestampEnum(Enum):
    def _generate_next_value_(name, start, count, last_values):
        import time
        return int(time.time() * 1000)  # Millisecond timestamp
    
    CREATED = ()     # Gets current timestamp
    UPDATED = ()     # Gets current timestamp
    ARCHIVED = ()    # Gets current timestamp

Complex Multi-Value Enums

from aenum import MultiValueEnum

class HttpStatusCode(MultiValueEnum):
    # Value, reason phrase, category
    OK = 200, 'OK', 'success'
    CREATED = 201, 'Created', 'success'
    BAD_REQUEST = 400, 'Bad Request', 'client_error'
    NOT_FOUND = 404, 'Not Found', 'client_error'
    SERVER_ERROR = 500, 'Internal Server Error', 'server_error'
    
    def __init__(self, code, phrase, category):
        self.code = code
        self.phrase = phrase
        self.category = category
    
    @property
    def is_success(self):
        return self.category == 'success'
    
    @property
    def is_error(self):
        return 'error' in self.category

# Usage
status = HttpStatusCode(404)
print(status.phrase)      # 'Not Found'
print(status.is_error)    # True

# Access by any value
status = HttpStatusCode('Bad Request')
print(status.code)        # 400

Ordered Multi-Value Enum

from aenum import OrderedEnum, MultiValueEnum

class Priority(OrderedEnum, MultiValueEnum):
    LOW = 1, 'low', 'minor'
    MEDIUM = 2, 'medium', 'normal'  
    HIGH = 3, 'high', 'major'
    CRITICAL = 4, 'critical', 'urgent'

# Comparison works with primary value
print(Priority.LOW < Priority.HIGH)        # True
print(Priority('urgent') > Priority('low')) # True

# Access by any value
print(Priority('major'))    # Priority.HIGH
print(Priority(2))          # Priority.MEDIUM

Common Use Cases

Version Numbering

from aenum import OrderedEnum

class Version(OrderedEnum):
    ALPHA = 1
    BETA = 2
    RC = 3
    STABLE = 4

def can_upgrade(from_version, to_version):
    return from_version < to_version

print(can_upgrade(Version.ALPHA, Version.STABLE))  # True

State Machines with Validation

from aenum import Enum, OrderedEnum

class WorkflowState(OrderedEnum):
    DRAFT = 1
    REVIEW = 2
    APPROVED = 3
    PUBLISHED = 4
    ARCHIVED = 5
    
    def can_transition_to(self, new_state):
        # Only allow forward transitions or archiving
        return new_state > self or new_state == WorkflowState.ARCHIVED

current = WorkflowState.DRAFT
print(current.can_transition_to(WorkflowState.REVIEW))    # True
print(current.can_transition_to(WorkflowState.PUBLISHED)) # True
print(current.can_transition_to(WorkflowState.DRAFT))     # False

Install with Tessl CLI

npx tessl i tessl/pypi-aenum

tessl/pypi-aenum

advanced-enums.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Advanced Enum Features

Capabilities

AutoNumberEnum

Usage Example

AutoEnum

Usage Example

OrderedEnum

Usage Example

UniqueEnum

Usage Example

MultiValueEnum

Usage Example

AddValueEnum

Usage Example

NoAliasEnum

Usage Example

Specialized String Enums

LowerStrEnum

UpperStrEnum

Enum Settings

Usage Example

Advanced Patterns

Custom Value Generation

Complex Multi-Value Enums

Ordered Multi-Value Enum

Common Use Cases

Version Numbering

State Machines with Validation

advanced-enums.mddocs/