typing: Dynamically Create Literal Alias from List of Valid Values

Question

I have a function which validates its argument to accept only values from a given list of valid options. Typing-wise, I reflect this behavior using a Literal type alias, like so:

from typing import Literal


VALID_ARGUMENTS = ['foo', 'bar']

Argument = Literal['foo', 'bar']


def func(argument: 'Argument') -> None:
    if argument not in VALID_ARGUMENTS:
        raise ValueError(
            f'argument must be one of {VALID_ARGUMENTS}'
        )
    # ...

This is a violation of the DRY principle, because I have to rewrite the list of valid arguments in the definition of my Literal type, even if it is already stored in the variable VALID_ARGUMENTS. How can I create the Argument Literal type dynamically, given the VALID_ARGUMENTS variable?

The following things do not work:

from typing import Literal, Union, NewType


Argument = Literal[*VALID_ARGUMENTS]  # SyntaxError: invalid syntax

Argument = Literal[VALID_ARGUMENTS]  # Parameters to generic types must be types

Argument = Literal[Union[VALID_ARGUMENTS]]  # TypeError: Union[arg, ...]: each arg must be a type. Got ['foo', 'bar'].

Argument = NewType(
    'Argument',
    Union[
        Literal[valid_argument]
        for valid_argument in VALID_ARGUMENTS
    ]
)  # Expected type 'Type[_T]', got 'list' instead

So, how can it be done? Or can't it be done at all?

Answer 1

Go the other way around, and build VALID_ARGUMENTS from Argument:

Argument = typing.Literal['foo', 'bar']
VALID_ARGUMENTS: typing.Tuple[Argument, ...] = typing.get_args(Argument)

It's possible at runtime to build Argument from VALID_ARGUMENTS, but doing so is incompatible with static analysis, which is the primary use case of type annotations. Building VALID_ARGUMENTS from Argument is the way to go.

I've used a tuple for VALID_ARGUMENTS here, but if for some reason you really prefer a list, you can get one:

VALID_ARGUMENTS: typing.List[Argument] = list(typing.get_args(Argument))

Answer 2

If anyone's still looking for a workaround for this:

typing.Literal[tuple(VALID_ARGUMENTS)]

Answer 3

Expanding on @user2357112's answer... it's possible to make variables for the individual strings of "foo" and "bar".

from __future__ import annotations
from typing import get_args, Literal, TypeAlias

T_foo = Literal['foo']
T_bar = Literal['bar']
T_valid_arguments: TypeAlias = T_foo | T_bar

FOO: T_foo = get_args(T_foo)[0]
BAR: T_bar = get_args(T_bar)[0]

VALID_ARGUMENTS = (FOO, BAR)


def func(argument: T_valid_arguments) -> None:
    if argument not in VALID_ARGUMENTS:
        raise ValueError(f"argument must be one of {VALID_ARGUMENTS}")


#mypy checks
func(FOO)  # OK
func('foo')  # OK
func('baz')  # error: Argument 1 to "func" has incompatible type "Literal['baz']"; expected "Literal['foo', 'bar']"  [arg-type]

reveal_type(FOO) # note: Revealed type is "Literal['foo']" 
reveal_type(BAR). # note: Revealed type is "Literal['bar']"
reveal_type(VALID_ARGUMENTS)  # note: Revealed type is "tuple[Literal['foo'], Literal['bar']]"

Though, it could be argued that using get_args in this case is overkill to avoid typing the string "foo" twice in code. (re: DRY vs WET) You could just as easily do the following with the same results.

from __future__ import annotations
from typing import Literal, TypeAlias

T_foo = Literal['foo']
T_bar = Literal['bar']
T_valid_arguments: TypeAlias = T_foo | T_bar

FOO: T_foo = 'foo'
BAR: T_bar = 'bar'

VALID_ARGUMENTS = (FOO, BAR)

As a word of caution with using Literal strings as annotations. Mypy will complain about this:

FOO = 'foo'

def func(argument: T_valid_arguments) -> None:
    ...

func(FOO) #  error: Argument 1 to "func" has incompatible type "str"; expected "Literal['foo', 'bar']"  [arg-type]

But the following is fine.

func('foo')  # OK

Answer 4

Here is the workaround for this. But don't know if it is a good solution.

VALID_ARGUMENTS = ['foo', 'bar']

Argument = Literal['1']

Argument.__args__ = tuple(VALID_ARGUMENTS)

print(Argument)
# typing.Literal['foo', 'bar']