Customize "return by value" in IntEnum

I have a class that extends IntEnum class that defines positions in a bit-encoded variable:

from enum import IntEnum

class Bits(IntEnum):

    @classmethod
    def data(cls, value: int):
        return [ e for e in cls if (1 << e) & value ]

class Status(Bits):
    READY = 0
    ERROR = 1
    WARNING = 2

x = Status.data(3) # x <- [<Status.READY: 0>, <Status.ERROR: 1>]
y = Status.data(4) # y <- [<Status.WARNING: 2>]
z = Status.data(8) # z <- []

Would it be possible to customize "return by value" of IntEnum without breaking anything? Since there will be multiple classes that will extend the Bits class, ideally this functionality should be implemented in the Bits class.

What I want to achieve is this:

x = Status(3) # x <- [<Status.READY: 0>, <Status.ERROR: 1>]
y = Status(4) # y <- [<Status.WARNING: 2>]
z = Status(8) # z <- []

I tried overriding the __call__ method (see enum — Support for enumerations), but it does not seem to be called in this case.

Yes you could customize the return value of an IntEnum class by defining a custom __new__ method for your Status class, this way it will change the behavior of how new instances are created without breaking the functionality of the IntEnum.

from enum import IntEnum, EnumMeta

class BitsMeta(EnumMeta):
    def __call__(cls, value):
        if isinstance(value, int):
            return [e for e in cls if (1 << e.value) & value]
        return super().__call__(value)

class Bits(IntEnum, metaclass=BitsMeta):

    @classmethod
    def data(cls, value: int):
        return [e for e in cls if (1 << e.value) & value]

class Status(Bits):
    READY = 0
    ERROR = 1
    WARNING = 2

x = Status(3)  # x <- [<Status.READY: 0>, <Status.ERROR: 1>]
y = Status(4)  # y <- [<Status.WARNING: 2>]
z = Status(8)  # z <- []

print(x)
print(y)
print(z)

Depending on how you need to use x, y, and z, IntFlag may work for you:

class Status(IntFlag):
    READY = 0
    ERROR = 1
    WARNING = 2

x = Status(3)
repr(x)
# <Status.ERROR|WARNING: 3>

Status.Error in x
# True

list(x)
# [<Status.Error: 1>, <Status.Warning: 2>]

This also seems more correct, since Status.READY shouldn't be part of Status(3), and Status.WARNING should be.

Looking closer, I see your values are actually bit positions -- so while the value attribute of Status.READY is 0, it's considered set if 1 is passed in... I can see that being confusing.

Here's how I would do it:

class Status(IntFlag, boundary=CONFORM):
    READY = auto()
    ERROR = auto()
    WARNING = auto()

x = Status(3)
repr(x)
# <Status.READY|ERROR: 3>

The CONFORM boundary means out-of-range values are ignored (like 8 in your OP).

The difference now between my solution and yours is the value shown for a single member:

# mine
<Status.READY: 1>

# yours
<Status.READY: 0>

You'll have to decide which version makes more sense in your environment.

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