hbutils.model.enum

Overview:

Useful utilities for python enum class.

This module provides utilities for working with Python enum classes, including: - AutoIntEnum: An IntEnum that automatically assigns sequential integer values - int_enum_loads: A decorator that adds a ‘loads’ method to IntEnum classes for flexible data parsing

AutoIntEnum

class hbutils.model.enum.AutoIntEnum(value)[source]

Overview:

An example from official documentation.

An IntEnum subclass that automatically assigns sequential integer values starting from 1. This allows you to define enum members with custom initialization values while the actual enum value is automatically assigned.

Examples::

>>> from hbutils.model import AutoIntEnum
>>> class MyEnum(AutoIntEnum):
...     def __init__(self, v):
...         self.v = v
...     A = 'a_v'
...     B = 'b_vv'
...     C = 'c_vvv'
...
>>> MyEnum.A
<MyEnum.A: 1>
>>> MyEnum.A.value
1
>>> MyEnum.A.v
'a_v'
>>> MyEnum.C
<MyEnum.C: 3>
>>> MyEnum.C.value
3
>>> MyEnum.C.v
'c_vvv'

int_enum_loads

hbutils.model.enum.int_enum_loads(enable_int: bool = True, value_preprocess: Callable[[int], int] | None = None, enable_str: bool = True, name_preprocess: Callable[[str], str] | None = None, external_process: Callable[[Any], _EnumType | None] | None = None)[source]

Overview:: Decorate an IntEnum class with a new loads class method that provides flexible parsing of various data types into enum members. The decorator supports integer value parsing, string name parsing, and custom external processing for other data types.

Parameters:

enable_int (bool) – Enable parsing from integer values, defaults to True.
value_preprocess (Optional[Callable[[int, ], int]]) – Preprocessor function for integer values before lookup, defaults to None which means no preprocessing.
enable_str (bool) – Enable parsing from string names, defaults to True.
name_preprocess (Optional[Callable[[str, ], str]]) – Preprocessor function for string names before lookup, defaults to None which means no preprocessing.
external_process (Optional[Callable[[Any, ], Optional[_EnumType]]]) – External processor function for handling unprocessable data types, defaults to None which means raise a TypeError.

Returns:

A decorator function that adds the loads method to an IntEnum class.

Return type:

Callable[[Type[_EnumType]], Type[_EnumType]]

Raises:

TypeError – If the decorated class is not a subclass of IntEnum.

Examples:

Simple usage

>>> from enum import IntEnum, unique
>>>
>>> @int_enum_loads()
>>> @unique
>>> class MyEnum(IntEnum):
>>>     A = 1
>>>     B = 2
>>>
>>> MyEnum.loads(1)    # MyEnum.A
>>> MyEnum.loads('A')  # MyEnum.A
>>> MyEnum.loads(2)    # MyEnum.B
>>> MyEnum.loads('B')  # MyEnum.B
>>> MyEnum.loads(-1)   # KeyError
>>> MyEnum.loads('a')  # KeyError
>>> MyEnum.loads('C')  # KeyError

Preprocessors

>>> from enum import IntEnum, unique
>>>
>>> @int_enum_loads(name_preprocess=str.upper, value_preprocess=abs)
>>> @unique
>>> class MyEnum(IntEnum):
>>>     A = 1
>>>     B = 2
>>>
>>> MyEnum.loads(1)    # MyEnum.A
>>> MyEnum.loads('A')  # MyEnum.A
>>> MyEnum.loads(2)    # MyEnum.B
>>> MyEnum.loads('B')  # MyEnum.B
>>> MyEnum.loads(-1)   # MyEnum.A
>>> MyEnum.loads('a')  # MyEnum.A
>>> MyEnum.loads('C')  # KeyError

External processor

>>> from enum import IntEnum, unique
>>>
>>> @int_enum_loads(external_process=lambda data: None)
>>> @unique
>>> class MyEnum(IntEnum):
>>>     A = 1
>>>     B = 2
>>>
>>> MyEnum.loads(1)    # MyEnum.A
>>> MyEnum.loads('A')  # MyEnum.A
>>> MyEnum.loads(2)    # MyEnum.B
>>> MyEnum.loads('B')  # MyEnum.B
>>> MyEnum.loads(-1)   # None
>>> MyEnum.loads('a')  # None
>>> MyEnum.loads('C')  # None