2

I am trying to make a variable that can be from a set of enum values, and then select a specific one when using it elsewhere.

from enum import Flag, auto


class MyEnum(Flag):
    FOO: int = auto()
    BAR: int = auto()
    MOO: int = auto()


def use_enum(my_enum: MyEnum) -> None:
    print(my_enum)


if __name__ == "__main__":
    any_enum: MyEnum = MyEnum.FOO | MyEnum.BAR
    print(type(any_enum.FOO))
    use_enum(my_enum=any_enum.FOO)  # Argument "my_enum" to "use_enum" has incompatible type "int"; expected "MyEnum"  [arg-type]mypy(error)

However the output shows:

<enum 'MyEnum'>
MyEnum.FOO

Is this a false positive from mypy?

Is there a different way this can be done so that any_enum can be used to suggest a subset from MyEnum?

PepsiBandit
  • 23
  • 2
  • 2
    I can't comment on the MyPy angle, but I can say that in Python 3.13 or 3.14, `any_enum.FOO` will no longer work. Use `MyEnum.FOO`. – Ethan Furman Feb 04 '23 at 20:51
  • Thanks, that is great to know. I wont want to go with this kind of solution then. I cant seem to find any other good way to make a subset of enums which can be used to give better autocomplete for which values are supported. I am trying to re-define the valid set of enums in different abstact base classes. – PepsiBandit Feb 04 '23 at 20:59
  • `any_enum.FOO` doesn't work because `FOO` is one of the two arguments used to define it; it works because `any_enum` itself doesn't *have* a `FOO` attribute, and so the whole thing evaluates to `MyEnum.FOO`. Try `x = MyEnum.BAR | MyEnum.MOO`, and `x.FOO` is still valid. – chepner Feb 04 '23 at 21:55

1 Answers1

1

mypy's either doing something wrong when accessing enum members from enum instances, or maybe (as the comments have pointed out) mypy is just deciding to conform with the deprecation of such an access.

When you access a class-level variable from an instance of MyEnum (e.g. MyEnum.BAR), mypy thinks the variable's type is whatever's annotated or inferred on the class body (which is technically true for other kinds of classes):

class MyEnum(Flag):
    FOO: int = auto()
    BAR: int = auto()
    MOO: int = auto()

>>> # mypy is correct here
>>> reveal_type(MyEnum.FOO)  # mypy: Revealed type is "Literal[error.MyEnum.FOO]?"
>>> # Based on the runtime implementation,
>>> # this should still be "Literal[error.MyEnum.FOO]?"
>>> reveal_type(MyEnum.FOO.FOO)  # mypy: Revealed type is "builtins.int"

But yeah, I don't think it's good practice to refer to enum members from the instance; although you technically can access any enum member through an enum instance like MyEnum.FOO.BAR.MOO.FOO at runtime, this is bad code in practice.

dROOOze
  • 1,727
  • 1
  • 9
  • 17