Decorators with parameters?

python

decorator-pattern

functionality

python-decorators

byAnton Shumikhin·Dec 27, 2024

To create a decorator with parameters, you must create a decorator factory. This forms a nested function structure, which permits the customization of behavior.

def with_args(deco_arg1, deco_arg2):
    def decorator(fn):
        @functools.wraps(fn)
        def wrapper(*fn_args, **fn_kwargs):
            # "Decorator parameters—assemble!" Just like Avengers but for code.
            print(f"Decorator args: {deco_arg1}, {deco_arg2}")
            return fn(*fn_args, **fn_kwargs)
        return wrapper
    return decorator

@with_args('param1', 'param2')
def my_func(x):
    # Firing my laser! Pew pew!
    print(f"Function arg: {x}")

my_func('test')

Here, with_args performs as a decorator factory that receives custom arguments. It returns a decorator, which then gives us back a wrapper function, delivering the desired logic.

Dissecting decorators and inner workings

The decorator factory

To get started, we feed the factory our desired modifiers (i.e., our decorator parameters). Here, it crafts a decorator to match our unique tastes.

The decorator function

Like a greedy python, the decorator function swallows a function only to spit it back out, coated in a shiny, new layer of functionality.

The wrapper function

Remember the Pac-Man game? Just like that, the wrapper function eagerly eats up any arguments and keyword arguments intended for the original function, running them along with extra behavior.

Power-ups and utilities

Calling functools.partial for backup

Like a helpful sidekick in a video game, functools.partial steps in to fill certain parameters automatically, making your decorator easier to read and handle. Less work for you—win-win!

Crafting meta-decorators for reusability

Imagine having a decorator for your decorator. Mind-blowing, right? But it lets you create adaptable and reusable decorators. Talk about meta!

Preserving identity with functools.wraps

In a world of masquerading code, be true. With @functools.wraps, you keep your decorated function's metadata intact, preserving its __name__ and __doc__.

Real-world scenarios

Type validation

With parameterized decorators, you can play the stern bouncer, checking type conditions of inputs, ensuring your elegant functions stay clear of type mismatch catastrophes.

Built-in snitch (Logging & Monitoring)

Be the omniscient seer of your code with decorators that offer custom logging or monitoring. Define log levels or meticulous metrics. You see it all!

Keymaster (Authentication & Authorization)

Pass roles or permissions as parameters to control who gets access to precious functions. Your decorators, your rules—no hackers shall pass!

Advanced usage and pitfalls

Stateful decorators with callable objects

Turn your decorator into a callable object to maintain juicy, succulent state. Now your decorator can offer bursts of new-age enhancements.

Assumed parameters (default)

Why specify parameters when you can assume some? Default parameters give more flexibility, not to mention, less typing. Your fingertips will thank you.

Watch for the booby traps

Beware! Over-adorning with parameter-laden decorators can lead to a jungle of confusing code. Simplicity is king. Heed its sage advice.

Examples and exploitation

Passing parameter types

Like a food taster, try feeding your decorator variety of data to ensure it behaves well under various data types. Safety first!

Modifying the wrapper

Need change? Modify your wrapper function, but tread lightly. The wrapper should still return the call to the decorated function after your custom additions.

Async functions

If your function has temporarily left the realm of synchronous and gone async, make sure your wrapper is awaiting its return, else it'll go async-native on you!

explain-codes / Python / Decorators with parameters?

Linked

How do I make function decorators and chain them together?



What does functools.wraps do?



What is the Python equivalent of static variables inside a function?



Getting list of parameter names inside python function



What can I do about "ImportError: Cannot import name X" or "AttributeError: ... (most likely due to a circular import)"?

