Decorator to validate that Python function arguments are positive

The user-facing name should be substantive. Give it a name to convey its behavior or purpose: require_positive_params() in the illustration below. On a more technical level, the user-facing function is not exactly a decorator so much as it is a decorator factory: it returns the actual decorator that replaces the original function. Similar thoughts can be applied to decorator_arguments.

The error message can convey the parameter name. It's more helpful to the reader and not a difficult change.

Use functools.wraps(). It's easy and useful.

Use inspect.signature() to support positionals from callers. Requires only a small addition.

from functools import wraps
from inspect import signature

def require_positive_params(*param_names):
    def decorator(func):
        @wraps(func)
        def wrapper(*xs, **kws):
            params = signature(func).bind(*xs, **kws).arguments
            for p in param_names:
                val = params[p]
                if val <= 0:
                    msg = f'Parameter should be positive: got {p}={val}'
                    raise ValueError(msg)
            return func(*xs, **kws)
        return wrapper
    return decorator

Next step: consider pulling the validation behavior out of the decorator. It's not too difficult to support a usage pattern like the one sketched below.

def require(validator, *param_names):
    def decorator(func):
        @wraps(func)
        ...

def is_positive(name, val):
    if val > 0:
        return True
    else:
        msg = f'Parameter should be positive: got {name}={val}'
        raise ValueError(msg)

def is_even(name, val):
    ...

@require(is_positive, 'c')
def sum1(a, b, c = 99):
    return a + b + c

@require(is_even, 'a', 'b')
def sum2(a, b = 0, c = 0):
    return a + b + c

I am against decorators or partial wrappers and recommend type hints to restrict the expected types' values.

This way, a source code checker with a reasonable type hinting feature can detect issues regarding the type constraints already while programming instead of during runtime. Since you speak of the user, I suspect your (pseudo) code is part of a library intended for use by others. When using such a library, I'd prefer that the IDE already detects such an issue instead of the unit tests.

NB: In your case you want to use Ge instead of Gt.

The decorator approach seems somewhat over-engineered and I am going to recommend against it. Consider a simple partial:

from functools import partial


def check_and_sum(positive_idx: tuple[int, ...], a: int = 1, b: int = 1, c: int = 1) -> int:
    addends = a, b, c
    for idx in positive_idx:
        val = addends[idx]
        if val < 1:
            raise ValueError(f'Addend {idx} with value {val} must be at least 1')

    return sum(addends)


sum_first_positive = partial(check_and_sum, (0,))
sum_second_positive = partial(check_and_sum, (1,))
sum_third_positive = partial(check_and_sum, (2,))
sum_all_positive = partial(check_and_sum, (0, 1, 2))

Tested as:

def test() -> None:
    assert sum_first_positive(1, 2, -3) == 0
    assert sum_second_positive(1, 2, -3) == 0
    assert sum_third_positive(1, -2, 3) == 2
    assert sum_third_positive(1, -2) == 0
    assert sum_all_positive(1, 2, 3) == 6

    try:
        sum_first_positive(0, 2, 3)
        raise AssertionError()
    except ValueError:
        pass

    try:
        sum_second_positive(1, 0, 2)
        raise AssertionError()
    except ValueError:
        pass

    try:
        sum_third_positive(1, 2, 0)
        raise AssertionError()
    except ValueError:
        pass

    for bad_index in range(3):
        addends = list(range(1, 4))
        addends[bad_index] = 0
        try:
            sum_all_positive(*addends)
            raise AssertionError()
        except ValueError:
            pass


if __name__ == '__main__':
    test()