How to represent enum in Python

Question

I know, I know, there are already similar questions in here and there. But their questions and answers are not exactly what I am looking for. Besides, they are locked question so I can not add a new answer to them. SMH.

Firstly, let's clarify the question to understand its scope. When using enum in other static languages like this:

public enum Size
{
    SMALL=0,
    MIDIUM=1,
    LARGE=2,
    BIG=2  // There can possibly be an alias
}

we want it to help us in:

1. Guard against typo when referencing a value. For example, var foo = Size.SMALL is valid, var bar = Size.SMAL should generate a lousy error.
2. Enum values can support strings, Such as HTTP404 = "Not Found", HTTP200 = "OK", .... (Therefore those implementations based on range(N) is unacceptable.)
3. When defining a parameter as a specific Enum type, it serves as a regulation to accept only that kind of values. For example, public void Foo(Size size) {...}

4. I also want the values to be first-class citizen in my Enum solution. Meaning, my functions def parser(value_from_the_wire): ... would like to consume some native values (such as an integer or a string etc.), rather than to consume an Enum member. This is the tricky part in standard Enum in Python 3:

   • assert 2 == MY_ENUM.MY_VALUE would only work when MY_ENUM was derived from IntEnum (and there is no default StrEnum although it is not difficult to subclass one by yourself)
   • assert 2 in MY_ENUM wouldn't work, even if MY_ENUM was derived from IntEnum.

Answer 1

TL;DR: Use venum

So my Python solution to satisfy the 3 criterias in the question, is based on namedtuple and the implementation seems more straightforward than the new built-in Enum in Python 3.

from collections import namedtuple

def enum(name=None, **kwargs):
    """
    :param name: An optional type name, which only shows up when debugging by print(...)
    """
    # This actual implementation below is just a one-liner, even within 80-char
    return namedtuple(name or "Const_%d" % id(kwargs), kwargs.keys())(**kwargs)

Usage is now simple.

# definition syntax
SIZE = enum("Size", SMALL=0, MEDIUM=1, LARGE=2, BIG=2)

# usage on referencing
print(SIZE.SMALL)   # got 0, instead of <SIZE.SMALL: 0>
try:
    print(SIZE.SMAL)    # got AttributeError
    assert False, "should not arrive this line"
except AttributeError:
    pass

# usage on comparison and contains-check
assert SIZE.MEDIUM == 1  # works. It won't work when using standard Enum (unless using IntEnum)
assert 1 in SIZE  # works. It won't work when using standard Enum (unless you wrote it as SIZE(1)).

# usage on regulating input value
def t_shirt_size(size):

    if size not in SIZE:
        raise ValueError("Invalid input value")

    print("Placing order with size: %s" % size)

t_shirt_size(SIZE.MEDIUM)   # works
t_shirt_size(2)             # also want this to work
try:
    t_shirt_size(7)             # got AssertionError
    assert False, "This line should not be reached!"
except ValueError:
    pass

EDIT 1: I was actually aware that there is a standard Enum module in Python 3 which is, feature-wise speaking, largely a superset to my one-liner implementation below. However there is one scenario that the standard Enum won't suit my need. I want the values to be a first-class citizen in my enum; I want my t_shirt_size(...) function to accept a real value, not just an enum member. The standard enum approach would NOT allow these 2 usages: assert SIZE.MEDIUM == 1 nor assert 1 in SIZE.

EDIT 2: Given that people tend to stereotype this topic as a duplicate, I planned to actually implement my approach as a standalone module with plenty of documentation. I even came up a cool name for it, venum, V stands for Value. It was at that time that I checked the name in pypi and found out there is already a package with that same name, using the same approach as mine, and documented well. So that settles it. I'll simply pip install venum instead. :-)

Answer 2

Implementing with Python 3's Enum:

from enum import IntEnum


class SIZE(Enum):

    SMALL = 0
    MEDIUM = 1
    LARGE = 2
    BIG = 2

    @classmethod
    def contains(cls, value):
        return any([e.value == value for e in cls])

and using:

print(SIZE.SMALL)   # got <SIZE.SMALL: 0>
print(SIZE.SMAL)    # got AttributeError

def t_shirt_size(size):
    assert size in SIZE, "Invalid input value"
    place_order_with_size(size)

t_shirt_size(SIZE.MEDIUM)   # works
t_shirt_size(7)             # got AssertionError