Custom enum creation in Python

Question

I can easily create a class like

class MyEnum(enum.Enum):
  BOB = "bob"
  RALPH = "ralph"
  ETC = "etc"

Then I can assign variables by enum value:

a = MyEnum('bob')

However -- I want to assign variables by things that could be the correct value. I.e., I'd like to do

a = MyEnum('bob')
b = MyEnum('Bob')
c = MyEnum('BOB')

and have them all work, and all map to the same enum value.

Is there a way of doing this without making a factory method? I've currently defined a create method, so a = MyEnum.create('Bob') works, but I'd like things to be seamless.

Ethan Furman · Answer 1 · 2018-08-28T19:25:56.443

2

The thing you are looking for is called _missing_ and is available in the stdlib as of Python3.6, and in aenum¹ as of 2.0.

class MyEnum(Enum):

    BOB = "bob"
    RALPH = "ralph"
    ETC = "etc"

    @classmethod
    def _missing_(cls, value):
        for member in cls:
            if member.value == value.lower():
                return member

If _missing_ fails to return a MyEnum member then EnumMeta will raise an exception (so _missing_ doesn't have to worry about that part)².

¹ Disclosure: I am the author of the Python stdlib Enum, the enum34 backport, and the Advanced Enumeration (aenum) library.

² Thanks, Aran-Fey, for bringing that up.

edited Aug 28 '18 at 19:25

answered Aug 28 '18 at 19:10

Ethan Furman

63,992
20
159
237

You should probably raise a `ValueError` in `_missing_`, otherwise things like `MyEnum('a')` just return `None`. – Aran-Fey Aug 28 '18 at 19:18
@Aran-Fey: `EnumMeta` checks for that -- if the return value is not an instance of the Enum (`MyEnum` in this case) then an exception is raised automatically... `ValueError` IIRC). – Ethan Furman Aug 28 '18 at 19:22
No exception is raised when I call `MyEnum('a')`. (Python 3.7 and stdlib `enum.Enum`) – Aran-Fey Aug 28 '18 at 19:23
@Aran-Fey: Huh. It works correctly in `aenum`. Would you like to file a bug report at bugs.python.org? – Ethan Furman Aug 28 '18 at 19:28
[Done.](https://bugs.python.org/issue34536) – Aran-Fey Aug 28 '18 at 19:38

Aran-Fey · Answer 2 · 2018-08-28T18:47:14.283

This can be achieved by subclassing EnumMeta, which is the metaclass responsible for defining the __call__ method that's invoked by MyEnum('Bob').

import enum

class CaseInsensitiveEnum(enum.EnumMeta):
    def __call__(self, string):
        string = string.lower()  # convert the string to lowercase
        return super().__call__(string)

class MyEnum(enum.Enum, metaclass=CaseInsensitiveEnum):
  BOB = "bob"
  RALPH = "ralph"
  ETC = "etc"

(Keep in mind that all the enum values have to be lowercase; i.e. BOB = 'Bob' would not work.)

Demonstration:

>>> MyEnum('Bob')
<MyEnum.BOB: 'bob'>
>>> MyEnum('Bob') is MyEnum.BOB
True

Subclassing `EnumMeta` is dangerous -- see [`When and where...`](https://stackoverflow.com/q/43730305/208880). — Ethan Furman, Aug 28 '18 at 19:13

Custom enum creation in Python

2 Answers2

Linked