将可选的关键字参数传递给装饰函数

Question

I would like to create a decorator that passes an optional keyword to the function it wraps. Something like this:

@mydecorator
def dummy_without_magic_word():
  print('hello world')

@mydecorator
def dummy_with_magic_word(magic_word):
  print(magic_word)

Basically, if the wrapped function has a specific keyword, it should be provided by the decorator; otherwise, just run the wrapped function.

What is the right way to accomplish this? Currently I'm just trying to pass in the keyword and check for a TypeError:

try:                                                                                           
  output = fn(redirect=redirect, **kwargs)                                               
except TypeError as e:
  if 'unexpected keyword argument' not in str(e):                                              
    raise e                                                                                    
  output = fn(*args, **kwargs)                                                           

but this seems brittle/unintuitive/weird.

Answer 1

To achieve that you can use the inspect module. Using the getfullargspec function, you can access all the argument names defined within the function. One remark is that if you want to parameterise the default value being passed to the decorated function, you will need a decorator factory. Here is a code example:

import inspect    

def my_decorator(default_value): # define decorator factory
    def decorator(fn): # define decorator
        def inner(*args, **kwargs): 
            fn_args = inspect.getfullargspec(fn).args # recover decorated function
                                                      # arguments
            
            if "magic_word" in fn_args: # check for argument
                return fn(*args, magic_word=default_value, **kwargs)
            else:
                return fn(*args, **kwargs)
        return inner
    return decorator

@my_decorator(default_value='Goodbye World')
def function_1():
    print('Hello World')

@my_decorator(default_value='Goodbye World')
def function_2(magic_word):
    print(magic_word)

Using this decorator, the result of the following code would be:

>>> function_1()
'Hello World'
>>> function_2()
'Goodbye World'

Notice that if you have keyword-only arguments, the decorator has to be slightly modified:

def my_decorator(default_value): # define decorator factory
    def decorator(fn): # define decorator
        def inner(*args, **kwargs): 
            fn_args = inspect.getfullargspec(fn).args # recover decorated function
                                                      # arguments
            fn_args += (inspect.getfullargspec(fn).kwonlyargs) # add kwonly args

            if "magic_word" in fn_args: # check for argument
                return fn(*args, magic_word=default_value, **kwargs)
            else:
                return fn(*args, **kwargs)
        return inner
    return decorator

@my_decorator(default_value='Goodbye World')
def function_3(a, *, magic_word):
    print(a, magic_word)

>>> function_3(1)
1 Goodbye World

Note that this implementation has an important limitation which is the fact that you must hard code the argument name that you will look for. This is the case, because python cannot cannot evaluate expressions for argument names. For example, if you try this implementation:

def my_decorator(search_word, default_value): # define decorator factory
    def decorator(fn): # define decorator
        def inner(*args, **kwargs): 
            fn_args = inspect.getfullargspec(fn).args # recover decorated function
                                                      # arguments
            fn_args += (inspect.getfullargspec(fn).kwonlyargs) # add kwonly args

            if search_word in fn_args: # check for argument
                return fn(*args, search_word=default_value, **kwargs)
            else:
                return fn(*args, **kwargs)
        return inner
    return decorator

@my_decorator(search_word='magic_word', default_value='Goodbye World')
def function_4(magic_word):
    print(magic_word)

Running the code would raise an error:

>>> function_4()
Traceback (most recent call last):
  File "/test.py", in <module>
    function_4()
  File "/test6.py", in inner
    return fn(*args, search_word=default_value, **kwargs)
TypeError: function_4() got an unexpected keyword argument 'search_word'

Answer 2

The sintaxe is like this:

def decorator(*args, **kwargs):
    print("Inside decorator")
     
    def inner(func):
         
        print("Inside inner function")
        print("I like", kwargs['param'])
         
        func()
         
    # reurning inner function   
    return inner
 
@decorator(param = "Hello world")
def my_func():
    print("Inside actual function")

Or:

@mydecorator
def dummy_with_magic_word(magic_word = 'hello world'):
  print(magic_word)

Answer 3

To inspect the argument names, you can dig into the function object like this:

arguments = fn.__code__.co_varnames[:fn.__code__.co_argcount]
if "redirect" in arguments:
    ...