This file shows how to use a str type enum in Python

test_enum.py

import enum

class Reduction(str, enum.Enum):
    max = 'max'
    min = 'min'
    sum = 'sum'
    mean = 'mean'
    prod = 'prod'


my_reduction = Reduction.max

print(f"My reduction: {my_reduction}")
# My reduction: max
print(f"My reduction type: {type(my_reduction)}")
print(type(my_reduction))
# My reduction type: <enum 'Reduction'>

assert my_reduction == Reduction.max
assert my_reduction == 'max'
assert my_reduction == Reduction('max')
assert my_reduction == Reduction(Reduction.max)

assert my_reduction != 'min'
assert my_reduction != Reduction.min
assert my_reduction != Reduction('min')
assert my_reduction != Reduction(Reduction.min)


from typing import Union
def reduce(*args, reduction: Union[str, Reduction]):
    assert reduction is not None
    # this line converts str or Reduction to Reduction
    # and throws an error if it failed.
    # e.g. ValueError: 'foo' is not a valid Reduction
    reduction = Reduction(reduction)
    
    if reduction == Reduction.max:
        return max(args)
    elif reduction == Reduction.min:
        return min(args)
    elif reduction == Reduction.sum:
        return sum(args)
    else:
        raise NotImplementedError
        
print(reduce(1, 2, 3, reduction=Reduction.sum))
print(reduce(1, 2, 3, reduction='sum'))
try:
    print(reduce(1, 2, 3, reduction='foo'))
except ValueError as e:
    # ValueError: 'foo' is not a valid Reduction
    print(f"{type(e).__name__}: {str(e)}")

# === string enum with default value ===
class TestEnum(str, enum.Enum):
    apple = 'apple'
    benana = 'benana'
    
    @classmethod
    def _missing_(cls, value):
        if value is None:
            return cls.apple

assert TestEnum(None) == TestEnum.apple
try:
    TestEnum("cat")
except ValueError as e:
    print(f"{type(e).__name__}: {str(e)}")
    # ValueError: 'cat' is not a valid TestEnum