打字：从有效值列表动态创建文字别名

Question

我有一个函数，可以验证其参数以仅接受给定的有效选项列表中的值。在打字方面，我使用

Literal

类型别名来反映这种行为，如下所示：

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}'
        )
    # ...

这违反了 DRY 原则，因为我必须重写 Literal 类型定义中的有效参数列表，即使它已经存储在变量

VALID_ARGUMENTS

中。 如何在给定

Argument

变量的情况下动态创建

VALID_ARGUMENTS

文字类型？

以下方法不起作用：

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

那么，如何才能做到呢？还是根本做不到？

Answer 1

反过来，从

VALID_ARGUMENTS

构建

Argument

：

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

可以在运行时从

Argument

构建

VALID_ARGUMENTS

，但这样做与静态分析不兼容，而静态分析是类型注释的主要用例。从

VALID_ARGUMENTS

构建

Argument

才是正确的道路。

我在这里使用了一个元组作为

VALID_ARGUMENTS

，但如果出于某种原因你真的更喜欢列表，你可以得到一个：

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

Answer 2

如果有人仍在寻找解决方法：

typing.Literal[tuple(VALID_ARGUMENTS)]

Answer 3

扩展@user2357112的答案...可以为

"foo"

和

"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']]"

Answer 4

这是解决此问题的方法。但不知道这是否是一个好的解决方案。

VALID_ARGUMENTS = ['foo', 'bar']

Argument = Literal['1']

Argument.__args__ = tuple(VALID_ARGUMENTS)

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