Enum of enums in Python?

You can use namedtuples to do something like this:

>>> from collections import namedtuple
>>> Foo = namedtuple('Foo', ['bar', 'barz'])
>>> Bar = namedtuple('Bar', ['element_a', 'element_b'])
>>> Barz = namedtuple('Barz', ['element_c', 'element_d'])
>>> bar = Bar('a', 'b')
>>> barz = Barz('c', 'd')
>>> foo = Foo(bar, barz)
>>> foo
Foo(bar=Bar(element_a='a', element_b='b'), barz=Barz(element_c='c', element_d='d'))
>>> foo.bar.element_a
'a'
>>> foo.barz.element_d
'd'

This is not a enum but, maybe solves your problem

Note The below is interesting, and may be useful, but as @abarnert noted the resulting A Enum doesn’t have Enum members — i.e. list(A) returns an empty list.

Without commenting on whether an Enum of Enums is a good idea (I haven’t yet decided 😉 , this can be done… and with only a small amount of magic.

You can either use the Constant class from this answer:

class Constant:
    def __init__(self, value):
        self.value = value
    def __get__(self, *args):
        return self.value
    def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, self.value)

Or you can use the new aenum library and its built-in skip desriptor decorator (which is what I will show).

At any rate, by wrapping the subEnum classes in a descriptor they are sheltered from becoming members themselves.

Your example then looks like:

from aenum import Enum, skip

class enumA(Enum):
    @skip
    class enumB(Enum):
        elementA = 'a'
        elementB = 'b'
    @skip
    class enumC(Enum):
        elementC = 'c'
        elementD = 'd'

and you can then access them as:

print(enumA)
print(enumA.enumB)
print(enumA.enumC.elementD)

which gives you:

<enum 'enumA'>
<enum 'enumB'>
enumC.elementD

The difference between using Constant and skip is esoteric: in enumA‘s __dict__ 'enumB' will return a Constant object (if Constant was used) or <enum 'enumB'> if skip was used; normal access will always return <enum 'enumB'>.

In Python 3.5+ you can even (un)pickle the nested Enums:

print(pickle.loads(pickle.dumps(enumA.enumC.elementD)) is enumA.enumC.elementD)
# True

Do note that the subEnum doesn’t include the parent Enum in it’s display; if that’s important I would suggest enhancing EnumMeta to recognize the Constant descriptor and modify its contained class’ __repr__ — but I’ll leave that as an exercise for the reader. 😉

I made an enum of enum implementing de __ getattr __ in the base enum like this

def __getattr__(self, item):
    if item != '_value_':
        return getattr(self.value, item).value
    raise AttributeError

In my case I have an enum of enum of enum

class enumBase(Enum):
    class innerEnum(Enum):
        class innerInnerEnum(Enum):
           A

And

enumBase.innerEnum.innerInnerEnum.A

works

Solution based on attrs. This also allows to implement attributes validators and other goodies of attrs:

import enum

import attr


class CoilsTypes(enum.Enum):
    heating: str = "heating"


class FansTypes(enum.Enum):
    plug: str = "plug"


class HrsTypes(enum.Enum):
    plate: str = "plate"
    rotory_wheel: str = "rotory wheel"


class FiltersTypes(enum.Enum):
    bag: str = "bag"
    pleated: str = "pleated"


@attr.dataclass(frozen=True)
class ComponentTypes:
    coils: CoilsTypes = CoilsTypes
    fans: FansTypes = FansTypes
    hrs: HrsTypes = HrsTypes
    filter: FiltersTypes = FiltersTypes


cmp = ComponentTypes()
res = cmp.hrs.plate

If you don’t care about inheritance, here’s a solution I’ve used before:

class Animal:
    class Cat(enum.Enum):
        TIGER = "TIGER"
        CHEETAH = "CHEETAH"
        LION = "LION"

    class Dog(enum.Enum):
        WOLF = "WOLF"
        FOX = "FOX"

    def __new__(cls, name):
        for member in cls.__dict__.values():
            if isinstance(member, enum.EnumMeta) and name in member.__members__:
                return member(name)
        raise ValueError(f"'{name}' is not a valid {cls.__name__}")

It works by overriding the __new__ method of Animal to find the appropriate sub-enum and return an instance of that.

Usage:

Animal.Dog.WOLF                    #=> <Dog.WOLF: 'WOLF'>
Animal("WOLF")                     #=> <Dog.WOLF: 'WOLF'>
Animal("WOLF") is Animal.Dog.WOLF  #=> True
Animal("WOLF") is Animal.Dog.FOX   #=> False
Animal("WOLF") in Animal.Dog       #=> True
Animal("WOLF") in Animal.Cat       #=> False
Animal("OWL")                      #=> ValueError: 'OWL' is not a valid Animal

However, notably:

isinstance(Animal.Dog, Animal)     #=> False

As long as you don’t care about that this solution works nicely. Unfortunately there seems to be no way to refer to the outer class inside the definition of an inner class, so there’s no easy way to make Dog extend Animal.

Try this:

# python3.7
import enum


class A(enum.Enum):
    def __get__(self, instance, owner):
        return self.value
    
    class B(enum.IntEnum):
        a = 1
        b = 2
    
    class C(enum.IntEnum):
        c = 1
        d = 2
    
    # this is optional (it just adds 'A.' before the B and C enum names)
    B.__name__ = B.__qualname__
    C.__name__ = C.__qualname__


print(A.C.d)        # prints: A.C.d
print(A.B.b.value)  # prints: 2