Decorator factory for decorator with optional kwargs

decorator_with_kwargs.py

from functools import partial, wraps
from inspect import signature
from typing import Callable


def decorator_with_kwargs(decorator: Callable) -> Callable:
    """Decorator factory to give decorated decorators the skill to receive
    optional keyword arguments.

    If a decorator "some_decorator" is decorated with this function:

        @decorator_with_kwargs
        def some_decorator(decorated_function, kwarg1=1, kwarg2=2):
            def wrapper(*decorated_function_args, **decorated_function_kwargs):
                '''Modifies the behavior of decorated_function according
                to the value of kwarg1 and kwarg2'''
                ...
            return wrapper

    It will be usable in the following ways:

        @some_decorator
        def func(x):
            ...

        @some_decorator()
        def func(x):
            ...

        @some_decorator(kwarg1=3)  # or other combinations of kwargs
        def func(x, y):
            ...

    :param decorator: decorator to be given optional kwargs-handling skills
    :type decorator: Callable
    :raises TypeError: if the decorator does not receive a single Callable or
        keyword arguments
    :raises TypeError: if the signature of the decorated decorator does not
        conform to: Callable, **keyword_arguments
    :return: modified decorator
    :rtype: Callable
    """
    @wraps(decorator)
    def decorator_wrapper(*args, **kwargs):
        if (len(kwargs) == 0) and (len(args) == 1) and callable(args[0]):
            return decorator(args[0])
        if len(args) == 0:
            return partial(decorator, **kwargs)
        raise TypeError(
            f'{decorator.__name__} expects either a single Callable '
            'or keyword arguments'
        )

    signature_values = signature(decorator).parameters.values()
    signature_args = [
        param.name for param in signature_values
        if param.default == param.empty
    ]

    if len(signature_args) != 1:
        raise TypeError(
            f'{decorator.__name__} signature should be of the form:\n'
            f'{decorator.__name__}(function: typing.Callable, '
            'kwarg_1=default_1, kwarg_2=default_2, ...) -> Callable'
        )

    return decorator_wrapper


# EXAMPLE USE CASES:

@decorator_with_kwargs
def multiple_runs(function, num_times=2):
    @wraps(function)
    def wrapper(*args, **kwargs):
        for _ in range(num_times):
            function(*args, **kwargs)
    return wrapper


# Decorator factory not being called directly
@multiple_runs
def func(x):
    print(x, end='')
func('a')
# > aa


# Decorator factory called without arguments
@multiple_runs()
def func(x):
    print(x, end='')
func('a')
# > aa


# Decorator factory called with keyword arguments
@multiple_runs(num_times=5)
def func(x):
    print(x, end='')
func('a')
# > aaaaa


# Expect TypeError:
# unexpected keyword argument
@multiple_runs(xpto=1)
def func(x):
    print(x, end='')
func('a')
# > TypeError: multiple_runs() got an unexpected keyword argument 'xpto'


# Expect TypeError:
# passing a non callable positional argument for the decorator:
@multiple_runs(1)
def func(x):
    print(x, end='')
func('a')
# > TypeError: multiple_runs expects either a single Callable or keyword arguments


# Expect TyeError:
# passing two positional arguments for the decorator:
@multiple_runs(1, 2)
def func(x):
    print(x, end='')   
func('a')
# > TypeError: multiple_runs expects either a single Callable or keyword arguments


# Expect TyeError:
# no workaround for something like this:
@multiple_runs(lambda x: x)
def func(x):
    print(x, end='')    
func('a')
# > TypeError: 'NoneType' object is not callable


# Expect TyeError:
# decorator with incorrect signature
@decorator_with_kwargs
def decorator_with_incorrect_signature(function, other_arg, x=1):
    pass
# > TypeError: decorator_with_incorrect_signature signature should be of the form:
# > decorator_with_incorrect_signature(function: typing.Callable, kwarg_1=default_1, kwarg_2=default_2, ...) -> Callable

thank you!