Preserving Signatures of Decorated Functions

Decorators are a powerful tool for enhancing the functionality of Python functions. However, they can sometimes obscure the original function's signature. This can be problematic for documentation, debugging, and automated tools.

Problem:

Consider a generic decorator that converts all arguments to integers:

def args_as_ints(f):
    def g(*args, **kwargs):
        args = [int(x) for x in args]
        kwargs = dict((k, int(v)) for k, v in kwargs.items())
        return f(*args, **kwargs)
    return g

While the decoration works as expected, the decorated function's signature is replaced with "args, *kwargs", losing information about the original arguments.

Workarounds:

Several workarounds exist, but none are fully satisfactory:

• Manually copying the signature into the docstring.
• Creating a new decorator for each specific signature.
• Manually constructing the decorated function with exec.

Solution:

decorator module offers an elegant solution:

import decorator

@decorator.decorator
def args_as_ints(f, *args, **kwargs):
    args = [int(x) for x in args]
    kwargs = dict((k, int(v)) for k, v in kwargs.items())
    return f(*args, **kwargs)

This decorator preserves the original function's signature by passing it as arguments to the wrapped function.

Improved Decorator:

@args_as_ints
def funny_function(x, y, z=3):
    """Computes x*y   2*z"""
    return x*y   2*z

Now, the decorated function funny_function retains its original signature:

>>> help(funny_function)
Help on function funny_function in module __main__:

funny_function(x, y, z=3)
    Computes x*y   2*z

Python 3.4 :

For Python 3.4 and above, functools.wraps provides a similar solution:

import functools

def args_as_ints(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args = [int(x) for x in args]
        kwargs = dict((k, int(v)) for k, v in kwargs.items())
        return func(*args, **kwargs)
    return wrapper

By using these techniques, decorators can enhance function functionality while preserving their original signatures, ensuring clarity and consistency in the codebase.