Support enum member `value` types

[PeterJCLaw]

Not sure if this would be in mypy or the typeshed, though it may need support in both.

Currently enum.IntEnum provides a way to have an enum whose value is an int, however all other enum.Enums have a .value of Any.

While this can be worked around in more recent versions of Python by adding a member without a value within the enum:

class MyEnum(str, enum.Enum):
    value: str
    FIRST = 'first'

This isn't ideal as it means that there are two places where this needs to be specified -- as an inherited type and within the class body.

It feels like it would be better if mypy was able to infer the member value type from the inheritance.

Aside: had generics existed before Enum, it feels like that might alternatively solved this, something like:

class MyEnum(enum.Enum[str]):
    FIRST = 'first'

Edit:
Note that this issue is about the general use-case of variables typed for the enum (such as x: MyEnum) -- mypy has long supported determining the type of specific members and their .values (e.g: reveal_type(MyEnum.FIRST.value) is already str or more recently Literal['first']).

I've put a more complete demo of this at https://gist.github.com/PeterJCLaw/d4334e498ab1391ee306886748e675f1.

[msullivan]

I think this could be handled by updating the enums plugin? (It might possibly need some supporting typeshed change also?)

[A5rocks]

If this to be added, maybe consider supporting this:

import enum

class Blah(int, enum.Enum):
    foo = '5'

print(repr(Blah.foo.value))  # would print `5`
reveal_type(Blah.foo.value)  # reveals "str" but should reveal "int"
# https://mypy-play.net/?mypy=latest&python=3.8&gist=46ca47b0d534d00f2218c8835783b8c2

I'm pretty sure this is an intended use of Enums? I'm not sure :P

[JelleZijlstra]

@A5rocks that seems evil, I think mypy should flag that as an error.

[A5rocks]

I'm pretty sure this issue is fixed now...? While my (with many apologies) code snippet doesn't work, this is what happens on current mypy:

import enum


class MyEnum(enum.Enum):
    FIRST = 'first'

x: MyEnum
reveal_type(x.value)  # N: Revealed type is "Literal['first']?"

(i.e. the .value is a union of all the enum members)

But this has been working since.... at least v0.902, which is was released before all the mentions here. I'm probably missing something?

[PeterJCLaw]

But this has been working since.... at least v0.902, which is was released before all the mentions here. I'm probably missing something?

Are you sure about the date there? v0.902 appears to be from June 2021, while this issue dates from April 2020 (over a year prior). Version 0.770, released in March 2020, looks like it would have been the latest at the time this was reported.

You are right though that the issue here isn't clear and it took me some testing & playing with this to remind myself what the issue was, or at least to find an issue which seems likely to be what I'd meant.

While use of a literal MyEnum.FIRST and its .value has always had a useful type assigned, the .value of a non-literal instance still has Any type.

I've put a fuller demo of this at https://gist.github.com/PeterJCLaw/d4334e498ab1391ee306886748e675f1, though the summary is:

class InheritEnum(str, enum.Enum):
    FIRST = 'first'
    SECOND = 'second'
    FAIL = 5

reveal_type(InheritEnum.FIRST)  # Revealed type is 'Literal[demo.InheritEnum.FIRST]?'
reveal_type(InheritEnum.FIRST.value)  # Revealed type is 'builtins.str' # newer: Revealed type is "Literal['first']?"

i: InheritEnum
reveal_type(i)  # Revealed type is 'demo.InheritEnum'
reveal_type(i.value)  # Revealed type is 'Any'

Edit: I've updated the original issue to clarify this.