Question

核心是，我尝试做的是采用一些看似未修饰的验证功能的功能：

def f(k: bool):
    def g(n):
        # check that n is valid
        return n
    return g

让它们看起来像装饰验证功能：

@k
def f():
    def g(n):
        # check that n is valid
        return n
    return g

这里的想法是k描述了所有实现功能的相同功能。

具体来说，这些功能都是返回＆＃39;验证＆＃39;用于voluptuous validation framework的函数。所以类型f()的所有函数都返回一个稍后由Schema()执行的函数。 k实际上是allow_none，也就是说确定None值是否合适的标志。一个非常简单的示例可能是示例使用代码：

x = "Some input value."
y = None
input_validator = Schema(f(allow_none=True))
x = input_validator(x)  # succeeds, returning x
y = input_validator(y)  # succeeds, returning None
input_validator_no_none = Schema(f(allow_none=False))
x = input_validator(x)  # succeeds, returning x
y = input_validator(y)  # raises an Invalid

在不更改样本使用代码的情况下我试图通过将未修饰的验证函数更改为修饰的验证函数来实现相同的结果。举一个具体的例子，改变这个：

def valid_identifier(allow_none: bool=True):
    min_range = Range(min=1)
    validator = Any(All(int, min_range), All(Coerce(int), min_range))
    return Any(validator, None) if allow_none else validator

对此：

@allow_none(default=True)
def valid_identifier():
    min_range = Range(min=1)
    return Any(All(int, min_range), All(Coerce(int), min_range))

从这两个函数返回的函数应该是等效的。

我尝试写的是这个，利用decorator库：

from decorator import decorator

@decorator
def allow_none(default: bool=True):
    def decorate_validator(wrapped_validator, allow_none: bool=default):
        @wraps(wrapped_validator)
        def validator_allowing_none(*args, **kwargs):
            if allow_none:
                return Any(None, wrapped_validator)
            else:
                return wrapped_validator(*args, **kwargs)
        return validator_allowing_none
    return decorate_validator

我有一个unittest.TestCase来测试它是否按预期工作：

@allow_none()
def test_wrapped_func():
    return Schema(str)

class TestAllowNone(unittest.TestCase):

    def test_allow_none__success(self):
        test_string = "blah"

        validation_function = test_wrapped_func(allow_none=False)
        self.assertEqual(test_string, validation_function(test_string))
        self.assertEqual(None, validation_function(None))

但我的测试会返回以下失败：

    def validate_callable(path, data):
        try:
>           return schema(data)
E           TypeError: test_wrapped_func() takes 0 positional arguments but 1 was given

我试过调试这个，但无法让调试器真正进入装饰。我怀疑由于命名问题，例如在this (very lengthy) blog post series中引发的问题，test_wrapped_func没有正确设置它的参数列表，因此装饰器永远不会被执行，但是它也可能完全不同。

我尝试了其他一些变化。从@allow_none删除函数括号：

@allow_none
def test_wrapped_func():
    return Schema(str)

我得到了一个不同的错误：

>       validation_function = test_wrapped_func(allow_none=False)
E       TypeError: test_wrapped_func() got an unexpected keyword argument 'allow_none'

删除@decorator失败了：

>       validation_function = test_wrapped_func(allow_none=False)
E       TypeError: decorate_validator() missing 1 required positional argument: 'wrapped_validator'

这是有道理的，因为@allow_none接受一个参数，因此逻辑上需要括号。替换它们会产生原始错误。

装饰者很微妙，我在这里明显遗漏了一些东西。这与编写函数类似，但它并不完全正常。关于如何实施这一点，我错过了什么？

Answer 1

我认为你将allow_none=default参数置于错误的嵌套级别。它应该在最里面的函数（包装器）上，而不是装饰器（中间层）。

尝试这样的事情：

def allow_none(default=True):    # this is the decorator factory
    def decorator(validator):    # this is the decorator
        @wraps(validator)
        def wrapper(*args, allow_none=default, **kwargs):    # this is the wrapper
            if allow_none:
                return Any(None, validator)
            else:
                return validator(*args, **kwargs)
        return wrapper
    return decorator

如果您不需要默认设置，您可以摆脱最外层的嵌套，只需在包装函数中使默认值为常量（如果您的调用者总是通过，则省略它值）。请注意，正如我在上面所写的那样，包装器的allow_none参数是一个仅关键字参数。如果你想将它作为位置参数传递，你可以将它移到*args之前，但这需要它是第一个位置参数，从API的角度来看可能不是这样。可能有更复杂的解决方案，但这个答案有点过分。

使用装饰器处理函数参数

1 个答案: