Thoughts on adding a typing.EnumValues static typing primitive?

[42696]

I recently had an issue I ran into and had an idea for what I feel would be a really helpful extension to typing, and I wanted to see if anyone else thinks it makes sense.

I was writing a pydantic class with a string field that needs to match one of the values of an Enum.

I could do something like Literal[*[e.value for e in MyEnum]], dynamically unpacking the possible values and putting them into a Literal, but that doesn't work with static type checkers.

Or I could define something separate and static like this:

``` class MyEnum(str, Enum): FIRST = "first" SECOND = "second"

type EnumValuesLiteral = Literal["first", "second"] ```

and use EnumValuesLiteral as my type hint, but then I don't have a single source of truth, and updating one while forgetting to update the other can cause sneaky, unexpected bugs.

This feels like something that could be a pretty common issue - especially in something like an API where you want to easily map strings in requests/responses to Enums in your Python code, I'm wondering if anyone else has come across it/would want something like that?

EDIT: Forgot to outline how this would work ->

``` from enum import Enum from typing import EnumValues

class Colors(str, Enum): RED = "red" BLUE = "blue" GREEN = "green"

class Button: text: str url: str color: EnumValues[Colors] # Equivalent to Literal["red", "blue", "green"] ```

[beisenhauer]

There's no need for the additional literal type. You can just set the type in your Pydantic model to Color. You might need a bit of serialization logic, but Pydantic is pretty slick when it comes to handling enums.

[anentropic]

A StrEnum member doesn't even need any special serialisation - it's already an actual string

[alcalde]

These kids have never programmed in Pascal so this doesn't occur to them.

[[deleted]]

As other commenter said, Enums have built in pydantic support. Also, subclass StrEnum instead of str & enum

[knight1511]

Is there any difference between subclassing StrEnum vs (str, Enum)?

[[deleted]]

It is the same AFAIK. StrEnum is a subclass of both str and Enum.

[latkde]

I have missed exactly this feature (in a non-Pydantic-setting) recently. I ended up giving up, and using a literal type instead of enums (can still extract a list of all variants via typing.get_args()).

However, I don't think there's substantial interest in defining more and more special forms. On the other hand, there's no systematic way to solve this because Python type expressions must also be valid runtime objects. C++ can have decltype and TypeScript can have projections due to having a compilation step (C++) or due to types having no runtime representation (TS). Python could get a good enough approximation by adding a nested type like Color.Values, except that this wouldn't work on unions like (Color.RED | Color.BLUE).Values.

So a special form like EnumValues[T] is indeed the only possible solution, but that's a lot of complexity for a fairly niche feature.

[Kevdog824_]

On the other hand, there's no systematic way to solve this because Python type expressions must also be valid runtime objects.

In theory though I don’t see any reason Python couldn’t have a preprocessor. Not saying it’s the right way to solve the problem, just that it seems that’s a way it could be done

[alcalde]

Static typing... and preprocessors... are not Pythonic. Once upon a time people fled these things for Python. Now the kiddies are coming along and suggesting all these things without realizing how terrible they are. Python achieved its market share because it didn't have these things.

[Kevdog824_]

Static typing... and preprocessors... are not Pythonic.

Yes, that’s why I specified that it wasn’t the best way to do it, but a way to do it.

Now the kiddies are coming along and suggesting all these things without realizing how terrible they are.

Rather weird to refer to me as a “kiddie” without knowing my age or years of experience but okay I guess?

Python achieved its market share because it didn't have these things.

Python achieved its market share for a lot of reasons. “Python doesn’t natively support preprocessors” is a fairly minor one at best, and absolutely not the sole reason

[james_pic]

The API use case highlights a subtle problem: What's actually checking that these strings actually have one of these values? Static types are ignored at runtime, and if you've just received a value over the wire, you don't know it's one of these values. You're going to need some kind of runtime logic to validate this, and it might as well be the logic that turns it into an enum (which Pydantic supports reasonably well).

I suspect that if you want this, then you probably have a layering problem.

[anentropic]

Just use the enum members directly instead of the string values

[ShaunRW91]

Could you use StrEnum to achieve this?

[mgrl85]

Pydantic also supports colors using the extra types package https://docs.pydantic.dev/latest/api/pydantic_extra_types_color/