Make enums idempotent

[randolf-scholz]

Feature

Currently, passing an enum into its own constructor forgets its value:

from enum import IntEnum

class Foo(IntEnum):
    x = 0
    y = 1

reveal_type(Foo(Foo.x))  # reveals Foo, not Foo.x
reveal_type(Foo.__new__)  # "def [Self <: IntEnum] (cls: type[Self], value: builtins.int) -> Self" 
reveal_type(Foo.__init__) # "def (self: builtins.object)"

Pitch

It should be straightforward to synthesize a signature that makes Foo(Foo.x) inferred as Foo.x.

[sterliakov]

Yes, but why? I think it's actually good enough. What's the sensible use of such pattern?

[randolf-scholz]

It's useful for example in a case like this:

from enum import IntEnum

class Option(IntEnum):
    x=0
    y=1

class Base[T: Option]:
    option: T

    def __init__(self, option: T) -> None:
        self.option = Option(option)  # for runtime safety

A user of the library that does not use a type-checker may pass a plain integer (Or maybe older versions of the code use plain integer rather than a dedicated enum). Therefore, it's best to be safe and apply the enum constructor anyway. But this currently raises an [assignment] error on the side of the library author.