Skip to main content

🎴 The decorator-decorator 🎴

Project description

🗃 dek - the decorator-decorator 🗃

dek decorates your decorators to diminish defects and drudgery.

Writing a Python decorator which takes no parameters isn't hard.

But writing a decorator with parameters is less easy - and more work if you want to decorate classes, like unittest.mock.patch does.

dek is a decorator for decorators that does this deftly with a single tiny function.

Example 1: a simple decorator with dek

TASK: write a decorator before that prints a function's name and its arguments before it executes.

With dek, it's a few lines:

import dek

def before(pfunc):
    return pfunc()

Done! To use your new decorator:

def phone(two, four=4):
    print('Calling', two + two, four * four)

one(32, four=3)

# That prints something like:
# functools.partial(<function phone at 0x7fafa8072b00>, 32, four=3)
# Calling 64 9

pfunc is a functools.partial, which represents the function call that dek intercepted. Your code can call pfunc as often as you like, or add or change parameters.

Example 2: same, without dek

import functools

def before(func):
    def wrapped(*args, **kwargs):
        print(func, args, kwargs)
        return func(*args, **kwargs)

    return wrapped

With dek it's a bit less work, but the real advantage comes when you have a decorator with a parameter.

Example 3: a decorator with a single optional parameter

Write a decorator before that prints a function's name, arguments and a label before it executes.

With dek, it's a trivial change from the previous solution.

import dek

def before(pfunc, label='dull'):
    print(label, pfunc.func, *pfunc.args)
    return pfunc()

def add(x, y):
    return x + y

def times(x, y):
    return x * y

print('Result', add(2, times(2, 3)))

# Prints:
#   Exciting! times 2 3
#   dull add 2 6
#   Result 8

Example 4: same, without dek

Without dek it's actual work that's easy to get wrong.

import functools

def before(func=None, label='dull'):
    if func is not None:
        def wrapped(*args, **kwargs):
            print(label, func.__name, *args)
            return func(*args, **kwargs)

        return wrapped

    return functools.partial(before, label=label)

Example 5: Deferred mode

For finer control over function signatures there is deferred mode, which lets you select what sort of signature you want to expose with a wrapped function that you create.

def before(func, label='debug'):
    def wrapped(foo, bar):
        print(label, foo, bar)
        return func(foo, bar)

    return wrapped

Example 6: Decorating a class

If you need to decorate methods on a class, there's a methods parameter to select which methods get decorated.

import dek

def before(pfunc):
    print('HERE', *pfunc.args)
    return pfunc()

class Class:
    def test_one(self):
        return 1

    def test_two(self):
        return 2

    def three(self):  # This won't get decorated
        return 1

# Test at the command line:
>>> cl = Class()
>>> cl.test_one(), cl.test_two(), cl.three()
(1, 2, 3)


This article talks more about decorators that take parameters and about dek in general.

For your advanced decorator desires, the PyPi module decorator does not duplicate duties that dek does, but does pretty anything else you could conceive of in a decorator library.

API Documentation

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

dek-1.1.0.tar.gz (5.2 kB view hashes)

Uploaded source

Built Distribution

dek-1.1.0-py3-none-any.whl (6.1 kB view hashes)

Uploaded py3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page