Optimizing extraction of kwargs from function with logging decorator

Question

What's the best way NOT to have to extracts the SAME KWARGS twice: once in the decorator (wrapper function) and once in the function itself.

Here is the function:

@close_logger
def close(**kwargs):
    """ returns close object"""

    # Get params
    session_attributes = kwargs.get('sessionAttrbiutes', {})
    message = kwargs.get('message', '')
    LID = kwargs.get('LIData', {})
    SANS = kwargs.get('SANS', [])
    FS = kwargs.get('fulfillmentState', 'Fulfilled')

    response = {
        'sessionAttributes': session_attributes,
        'dialogAction': {
            'type': SANS,
            'fulfillmentState': FS,
            'message': {
                'contentType': LID,
                'content': message
            }
        }
    }

    return response

and here is the decorator (used for logging the close event):

def close_logger(func):

    @functools.wraps(func)
    def wrapper(**kwargs):

        # Get params
        session_attributes = kwargs.get('sessionAttrbiutes', {})
        message = kwargs.get('message', '')
        LID = kwargs.get('LIData', {})
        SANS = kwargs.get('SANS', [])
        FS = kwargs.get('fulfillmentState', 'Fulfilled')

        logger.debug('Logging:\n Function:{} Session Attributes: {}\n \
        Message{}\n: LID: {}\n SANS: {}\n FS: {}'.format(
            func.__name__,
            session_attributes,
            message,
            LID,
            SANS,
            FS
        ))

        return func(**kwargs)

    return wrapper

Answer 1

Start by making your keyword arguments explicit for the close function.

def close(sessionAttrbiutes=None, message='', LIData=None, SANS=None, fulfillmentState='Fulfilled'):
    if sessionAttrbiutes is None:
        sessionAttrbiutes = {}
    ...

Note that I used None as default values for the mutable default values to avoid a common pitfall.

Then in your decorator use inspect.getfullargspec, similar to this answer:

import inspect
import functools

def get_default_args(func):
    """
    returns a dictionary of arg_name:default_values for the input function
    """
    argspec = inspect.getfullargspec(func)
    return dict(zip(reversed(argspec.args), reversed(argspec.defaults)))


def close_logger(func):
    @functools.wraps(func)
    def wrapper(**kwargs):
        kwargs_local = get_default_args(func)
        kwargs_local.update(kwargs)

        logger.debug("""Logging:
Function: {}
Session Attributes: {sessionAttrbiutes}
Message: {message}
LID: {LIData}
SANS: {SANS}
FS: {fulfillmentState}""".format(func.__name__, **kwargs_local))

        return func(**kwargs)

    return wrapper

This will raise a KeyError if one of those fields is not defined (either in the signature or the passed keywords). Of course it will show None for those where that is the default in the signature.

The full argspec will also contain positional arguments, so you might be able to figure those out as well.

Answer 2

**-notation can be used within function argument lists to both pack and unpack arguments.

**-notation within a function definition collects all the values into a dictionary.

>>> def kwargs_in_definition(**kwargs): return kwargs
>>> kwargs_in_definition(arg1 = 1, arg2 = 2, arg3 = 3)
{'arg1': 1, 'arg2': 2, 'arg3': 3}

**-notation within a function call unpacks all the values as keyword argumnts.

def kwargs_in_call(arg1 =0, arg2 = 0, arg3 = 0): return arg1, arg2, arg3

So when you pass kwargs (kwargs := {'arg1': 1, 'arg2': 2, 'arg3': 3}) to kwargs_in_call you get this:

>>> kwargs_in_call(kwargs)
({'arg1': 1, 'arg2': 2, 'arg3': 3}, 0, 0) # kwargs is used as arg1.

...but if you unpack it first:

>>> kwargs_in_call(**kwargs)
(1, 2, 3) # kwargs unapcks to "arg1 = 1, arg2 = 2, arg3 = 3"

All of this applies for * as well

Your specific case:

**kwargs in a function defintion gives you a regular old dict. You can turn that dictionary into a list -- however you wish to do that --, unpack that list and pass it on to another function. You'll have to account for ordering though, so it's difficult to make this work for all functions.

I'm not sure why you insist on your decorator function taking keyword arguments while your decorated function doesn't. You can, of-course, do whatever you want, but I would argue against such an approach, because you're decorator function is changing how your actual function behaves.

If you manage to sort those keyword arguments in to a valid argument list you'll be good.

Hope this helps.

EDIT: Oh, I forgot to point out that you're unpacking **kwargs in your decorator function (return func(**kwargs)) and then you're repacking them in your actual function (def close(**kwargs):. I'll be honest, that's a silly thing to do.

EDIT: You can use inspect.getargspec or inspect.signature to get a functions argument list. If you just have your decorator take in *args, you can match each value to a corresponding name from the argument list.