Arguments for Python decorators

Question

So with the following...

    def makeBold(fn):
        def wrapped():
            return '<b>'+fn()+'</b>'
        return wrapped

    @makeBold
    def produceElement():
        return 'hello'

The result is

    <b>hello</b>

I would like to do something like this...

    @makeBold(attrib=val, attrib=val)
    def produceElement():
        return 'hello'

and have the result be something like...

    <b attrib=val, attrib=val>hello<b/>

Any advice would be great!

Answer 1

Wrap your function with another function:

import functools
def makeBold(**kwargs):
    attribstrings = str(kwargs) # figure out what to do with the dict yourself 
    def actualdecorator(fn):
        @functools.wraps(fn)
        def wrapped():
            return '<b'+attribstrings+'>'+fn()+'</b>'
        return wrapped
    return actualdecorator

I leave working out how to build the string as an exercise for the reader.

Note that the structure of a decorator expression is @ <callable object of one parameter, w> <declaration of callable object, f>. It's effect is f = w(f). Accordingly, w (the decorator) has to return a callable of the same type as f.

In @makebold(foo)def bar(x):pass, the expression makebold(foo) is the decorator - that is, the final effect of the decorator is bar = makebold(foo)(bar), and so bar ends up holding wrapped.

The purpose of functools.wraps is to fix up properties of the decorated function to copy over metadata (such as name and docstring) from the argument function to the wrapped function, so that the whole wrapping process is transparent.

Answer 2

I'm perhaps dubious that this is a good use case for decorators, but here:

import string

SelfClosing = object()

def escapeAttr(attr):
    # WARNING: example only, security not guaranteed for any of these functions
    return attr.replace('"', '\\"')

def tag(name, content='', **attributes):
    # prepare attributes
    for attr,value in attributes.items():
        assert all(c.isalnum() for c in attr)  # probably want to check xml spec
    attrString = ' '.join('{}="{}"'.format(k,escapeAttr(v)) for k,v in attributes.items())

    if not content==SelfClosing:
        return '<{name} {attrs}>{content}</{name}>'.format(
            name = name,
            attrs = attrString,
            content = content
        )
    else:  # self-closing tag
        return '<{name} {attrs}/>'

Example:

def makeBoldWrapper(**attributes):
    def wrapWithBold(origFunc):
        def composed(*args, **kw):
            result = origFunc(*args, **kw)
            postprocessed = tag('b', content=result, **attributes)
            return postprocessed
        return composed
    return wrapWithBold

Demo:

@makeBoldWrapper(attr1='1', attr2='2')
def helloWorld(text):
    return text

>>> print( helloWorld('Hello, world!') )
<b attr2="2" attr1="1">Hello, world!</b>

The common misconception with decorators is that the parameters (attr1=...) are parameters to the decorator @myDecorator; that is not the case. Rather the result of the function call myDecoratorFactory(attr1=...) is calculated as someresult and becomes an anonymous decorator @someresult. Therefore 'decorators with arguments' are actually decorator factories that need to return a decorator as a value.

Answer 3

In order to do something like this, you would need a function that returns a decorator function. So in this case (assuming you want to accept arbitrary attributes), you would write

def format_attribs(kwargs):
    """Properly formats HTML attributes from a dictionary"""
    return ' '.join('{}="{}"'.format(key, val) for key,val in kwargs.iteritems())

def makeBold(**kwargs):
    attribs = format_attribs(kwargs)
    def _makeBold(fn):
        def wrapped():
            return '<b ' + attribs + '>' + fn() + '</b>'
        return wrapped
    return _makeBold

In order to make this makeBold function a little more general, you want to pass arguments through to fn and keep other information such as function name using functools.wraps:

import functools
def makeBold(**kwargs):
    attribs = format_attribs(kwargs)
    def _makeBold(fn):
        @wraps(fn)
        def wrapped(*args, **kwargs):
            return '<b ' + attribs + '>' + fn(*args, **kwargs) + '</b>'
        return wrapped
    return _makeBold