Skip to main content

Decorator utility that operates on black magic

Project description

Build Status Coverage Latest Version Downloads License

Metaprogramming modules that operate on black magic!

Currently there is only one module available. However, I am all open for cool ideas.


This is intended to become a more modern and flexible replacement for the the well known decorator module. This module benefits an API for more flexible usage. The behaviour of the decorator module can easily be duplicated.

For those who don’t know the decorator module: It can be used to create wrappers for functions that look identical to the original - a common task when replacing functions via decorators.

Furthermore, this module makes it possible to create wrappers with modified signatures. Currently, the only specialized function that is explicitly dedicated to this purpose is partial. If you are interested in doing more complex modifications you can pass a dynamically created Signature to wraps. If you make something useful, please consider contributing your functionality to this module.


wraps can be used similarly to the standard functools.wraps function. However, it returns a real function, i.e. something that will have a useful signature when being inspected with help() or by other metaprogramming tools. Furthermore, it knows how to copy the signature exactly, even remembering object identity of default arguments and annotations:

>>> from black_magic.decorator import wraps

>>> def real(a=[])
...     return a

>>> @wraps(real)
... def fake(*args, **kwargs):
...     return args

>>> fake()[0] is real()
>>> fake(a=1)

If you want to get real crazy you can even use ast.expr’s:

>>> import ast
>>> fake = wraps(real)(ast.Num(n=1))
>>> fake(0)

WARNING: before using functools.partial with any of the functions in this module, make sure to read the warning below!


This is similar to the functools.partial function.

>>> from black_magic.decorator import partial

>>> def real(arg):
...     print(arg)
>>> partial(real, arg=0)()

There are some differences, though:

  • this function returns a function object which looks like the input function, except for the modified parameters.

  • all overwritten parameters are completely removed from the signature. In functools.partial this is true only for arguments bound by position.

  • the **kwargs are stripped first, then *args

    >>> partial(lambda a,b,c: (a,b,c), 2, a=1)(3)
    (1, 2, 3)
  • by leaving the first argument empty partial can act as decorator:

    >>> @partial(None, 1, bar=0)
    ... def foo(bar, lum):
    ...     return bar, lum
    >>> foo()
    (0, 1)
  • Note, that the function returned by partial(None, ...) is just like partial: it can bind additional arguments and you can still leave the first parameter unspecified. This has weird properties and should not be used in production code, but I thought it would be great to add some additional brainfuck, to see where it will go.

CAUTION: Iterative invocation of partial (with None as first argument) doesn’t hide parameters the same way that partial applied to a function does, i.e. you can move bound arguments to the right in later calls. In code:

>>> partial(None, 1)(a=0)(lambda a, b: (a, b))()
(0, 1)


The returned value can be called like partial bind a function to the parameters given here. In fact, partial = metapartial().

Binding further keyword arguments via the returned function will overwrite keyword parameters of previous bindings with the same name.

>>> @metapartial(1, a=0, c=3)
... def func(a, b, *args, **kwargs):
...     return (a, b, args, kwargs)
>>> func(2)
(0, 1, (2,), {'c': 3})


This is the canonic utility to create decorators:

>>> from black_magic.decorator import decorator

>>> @decorator
... def plus_one(fn):
...     def fake(*args, **kwargs):
...         return 1 + fn(*args, **kwargs)
...     return fake

>>> @plus_one
... def mul_plus_one(a, b):
...     return a * b

>>> mul_plus_one(2, 3)


flatorator imitates the functionality of the well known decorator module.

>>> from black_magic.decorator import flatorator

>>> @flatorator
... def times_two(fn, *args, **kwargs):
...     return 2 * fn(*args, **kwargs)

>>> @times_two
... def add_times_two(a, b):
...     return a + b

>>> add_times_two(1, 2)

Under the hood

Q: This uses ugly str concat and eval code, right?

A: No, it uses ugly abstract syntax tree code to do its dynamic code generation.

WARNING: performance hits incoming

Decorating a function with the tools in this module is a quite costy operation, so don’t do it very often! Invoking the wrapper is no problem on the other hand.

WARNING: functools.partial is evil

Be careful when passing functools.partial objects into .wraps, or any black magic functions more generally. functools.partial features very unsensible handling of arguments that are bound by keyword. These, and all subsequent arguments, become keyword-only parameters. Consider the following example:

>>> import functools
>>> def func(a, b, *args, **kwargs):
...     return (a, b, args, kwargs)
>>> part = functools.partial(func, a=0)
>>> part(1)
Traceback (most recent call last):
TypeError: func() got multiple values for argument 'a'

Furthermore, note that the *args parameter becomes completely inaccessible, forever!

For compatibility between python versions and ease of use, I chose to handle functools.partial objects as if you had actually used black_magic.decorator.partial with the same arguments, i.e.:

>>> wrap = wraps(part)(part)
>>> wrap(1, 2, c=3)
(0, 1, (2,), {'c':3})

Note, the signature imposed by .wraps(functools.partial(f)) is equivalent to the signature of .wraps(.partial(f)), which might come unexpected.


This module has been tested to work on python{2.6, 2.7, 3.2, 3.3} and PyPy1.9 using Travis CI.


To the extent possible under law, Thomas Gläßle has waived all copyright and related or neighboring rights to black-magic. This work is published from: Germany.

To the extent possible under law, the person who associated CC0 with black-magic has waived all copyright and related or neighboring rights to black-magic.

You should have received a copy of the CC0 legalcode along with this work. If not, see



  • fix signature of black_magic.decorator.partial: remove named parameter func that can prevent binding of the a parameter with the same name into **kwargs
  • return value of partial can now be used for further parameter (re-)binding if the function was left open. CAREFUL: this might have unexpected characteristics, such as moving positional parameters to the right in later calls.
  • add metapartial function, that accepts only *args, **kwargs to be bound, while the function to be used can only be specified in a second step.
  • slightly improve performance of black_magic.decorator. Is now approximately the same as the performance of the decorator module.


  • convert all functools.partial to black_magic.partial with the same parameters.


  • partial support for functools.partial


  • fix functools.update_wrapper emulation in black_magic.decorator.wraps()


  • add black_magic.decorator.partial


  • support any callable to be passed to ASTorator.decorate
  • convert README to .rst

Project details

Download files

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

Files for black-magic, version 0.0.9
Filename, size File type Python version Upload date Hashes
Filename, size black-magic-0.0.9.tar.gz (16.0 kB) File type Source Python version None Upload date Hashes View

Supported by

Pingdom Pingdom Monitoring Google Google Object Storage and Download Analytics Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page