Python输入：文字类型参数的验证装饰器

如何解决Python输入：文字类型参数的验证装饰器

通常，我会遇到仅接受有限的一组值的函数。我知道如何使用typing.Literal来在类型注释中反映这种行为：

import typing


def func(a: typing.Literal['foo','bar']):
    pass

我想拥有一个装饰器@validate_literals，它可以验证的参数与其类型一致：

@validate_literals
def picky_typed_function(
    binary: typing.Literal[0,1],char: typing.Literal['a','b']
) -> None:
    pass

，以便根据参数类型定义的限制来验证输入，并在出现违反情况时引发ValueError：

picky_typed_function(0,'a')  # should pass
picky_typed_function(2,'a')  # should raise "ValueError: binary must be one of (0,1)')"
picky_typed_function(0,'c')  # should raise "ValueError: char must be one of ('a','b')"
picky_typed_function(0,char='c')  # should raise "ValueError: char must be one of ('a','b')"
picky_typed_function(binary=2,char='c')  # should raise "ValueError: binary must be one of (0,1)"

typing类型检查被设计为静态的，并且不会在运行时发生。如何利用类型定义进行运行时验证？

解决方法

我们可以使用inspect.signature检查修饰的（验证的）函数的签名，并通过{{3}获取参数注释的“来源”来检查函数的哪些参数被键入为Literal别名。 }（或者，对于版本低于3.8的python版本，请使用typing.get_origin()），然后使用[{typing.get_args()]（__origin__）（从嵌套的Literal定义中递归地进行迭代）来检索有效值别名。

要做到这一点，剩下要做的就是找出哪些参数已作为位置参数传递，并将对应的值映射到参数名称，以便可以将该值与参数的有效值进行比较。参数。

最后，我们使用带有https://stackoverflow.com/a/64522240/3566606的标准配方来构建装饰器。最后，这是代码：

import inspect
import typing
import functools


def args_to_kwargs(func: typing.Callable,*args: list,**kwargs: dict) -> dict:
    args_dict = {
        list(inspect.signature(func).parameters.keys())[i]: arg
        for i,arg in enumerate(args)
    }

    return {**args_dict,**kwargs}


def valid_args_from_literal(annotation: _GenericAlias) -> Set[Any]:
    args = get_args(annotation)
    valid_values = []

    for arg in args:
        if typing.get_origin(parameter.annotation) is Literal:
            valid_values += valid_args_from_literal(arg)
        else:
            valid_values += [arg]

    return set(valid_values)


def validate_literals(func: typing.Callable) -> typing.Callable:
    @functools.wraps(func)
    def validated(*args,**kwargs):
        kwargs = args_to_kwargs(func,*args,**kwargs)
        for name,parameter in inspect.signature(func).parameters.items():
            # use parameter.annotation.__origin__ for Python versions < 3.8
            if typing.get_origin(parameter.annotation) is typing.Literal:
                valid_values = valid_args_from_literal(parameter.annotation)
                if kwargs[name] not in valid_values:
                    raise ValueError(
                        f"Argument '{name}' must be one of {valid_values}"
                    )

        return func(**kwargs)

    return validated

这给出了问题中指定的结果。

我还发布了Python版本runtime-typing的Alpha版，以执行运行时类型检查：functools.wraps（文档：https://pypi.org/project/runtime-typing/）处理的案件不仅仅限于typing.Literal，例如typing.TypeVar和typing.Union。

,

from typing import Literal
from valdec.dec import validate

@validate
def func(a: Literal["foo","bar"]) -> str:
    return a

assert func("bar") == "bar"


@validate("return",exclude=True)
def func(binary: Literal[0,1],char: Literal["a","b"]):
    return binary,char

assert func(0,"a") == (0,"a")


func(2,"x")
# valdec.utils.ValidationArgumentsError: Validation error <class 
# 'valdec.val_pydantic.ValidationError'>: 2 validation errors for argument 
# with the name of:
# binary
#   unexpected value; permitted: 0,1 (type=value_error.const; given=2; 
#   permitted=(0,1))
# char
#   unexpected value; permitted: 'a','b' (type=value_error.const; given=x; 
#   permitted=('a','b')).

valdec：https://github.com/EvgeniyBurdin/valdec