Type Safe Literal Values Extraction with Provisional PEP 747 Support

[Vezzp]

Sometimes I need to iterate over Literal values and for such cases I tend to use get_args, which revealed type is tuple[Any, ...].

In those moment I wished I had type safe Literal value extraction possible, but it wasn't: bounding TypeVar with Literal isn't allowed as well wrapping type around such «generic literal».

So, when PEP 747 became provisionally supported in Pyright I started playing around with it and realized it's actually possible to achieve what I want for Literal types: it's hacky but still.

See the code in Pyright playground or the code snippet provided below.

from typing_extensions import Literal, TypeForm


def get_literal_values[T: Literal[...]](__t: TypeForm[T], /) -> tuple[T, ...]: ...  # type: ignore


type L = Literal[0, True, Literal["hello", Literal["world"]]]

# Type of "get_literal_values(L)" is "tuple[Literal[0, True, 'hello', 'world'], ...]"
reveal_type(get_literal_values(L))

Note that ellipsis inside Literal is crucial, nothing works without it.

Is this Pyright «bug»? Should such behavior—very handy I'd say 🙂— be allowed?

[erictraut]

The expression Literal[...] is not a legal type expression. That's why you needed to add the # type: ignore comment. Its use as an upper bound isn't enforced in this case, so you might as well just delete the upper bound. It's serving no purpose other than to generate a type error.

The rest of the code looks fine and is an appropriate use of PEP 747. To cover all possible cases, your implementation of get_literal_values would need to be pretty complex. It would need to decode a variety of type form objects including instances of TypeAliasType, LiteralAlias, UnionType, int, NoneType, bool, LiteralString, Enum, and str.

[Vezzp]

Thanks for the very detailed answer!

By saying «you might as well just delete the upper bound» you mean I could just write:

def get_literal_values[T: Literal](__t: TypeForm[T], /) -> tuple[T, ...]: ...  # type: ignore

But this would lead to tuple[Unknown, ...] type of returned value as passing my L would be type checked as incorrect due to:

Argument of type "TypeAliasType" cannot be assigned to parameter "__t" of type "TypeForm[T@get_literal_values]" in function "get_literal_values"
  "TypeAliasType" is not assignable to "TypeForm[T@get_literal_values]"  (reportArgumentType)

[erictraut]

By "delete the upper bound", I mean:

def get_literal_values[T](__t: TypeForm[T], /) -> tuple[T, ...]: ...

[JacobHayes]

In addition to listing Literal values, I've wanted a way check if a given value is a valid member (rather than using Enums) and landed on this:

from __future__ import annotations  # Required as TypeForm is not yet released in typing_extensions

from typing import TYPE_CHECKING, Literal, TypeAliasType, TypeIs, assert_type, get_args, get_origin

if TYPE_CHECKING:  # Required as TypeForm is not yet released in typing_extensions
    from typing_extensions import TypeForm

type PossibleValues = Literal["a", "b"]


def is_literal_value[T](value: object, typx: TypeForm[T]) -> TypeIs[T]:
    if isinstance(typx, TypeAliasType):
        typx = typx.__value__
    if get_origin(typx) is Literal:
        return value in get_args(typx)
    return False


def check(x: str):
    if is_literal_value(x, PossibleValues):
        assert_type(x, PossibleValues)
        print(f"{x} is in PossibleValues")
    else:
        assert_type(x, str)
        print(f"{x} is not in PossibleValues")


check("a")
check("z")