"""Examples of decorators

See https://realpython.com/primer-on-python-decorators/

The decorators with dependencies outside of the standard library (Flask

and Pint) are available in separate files.

"""

import functools

import time

PLUGINS = dict() # Dictionary used by @register to store plugins

def do_twice(func):

"""Run the decorated function twice"""

@functools.wraps(func)

def wrapper_do_twice(*args, **kwargs):

func(*args, **kwargs)

return func(*args, **kwargs)

return wrapper_do_twice

def timer(func):

"""Print the runtime of the decorated function"""

@functools.wraps(func)

def wrapper_timer(*args, **kwargs):

start_time = time.perf_counter()

value = func(*args, **kwargs)

end_time = time.perf_counter()

run_time = end_time - start_time

print(f"Finished {func.__name__!r} in {run_time:.4f} secs")

return value

return wrapper_timer

def debug(func):

"""Print the function signature and return value"""

@functools.wraps(func)

def wrapper_debug(*args, **kwargs):

args_repr = [repr(a) for a in args]

kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]

signature = ", ".join(args_repr + kwargs_repr)

print(f"Calling {func.__name__}({signature})")

value = func(*args, **kwargs)

print(f"{func.__name__!r} returned {value!r}")

return value

return wrapper_debug

def slow_down_1sec(func):

"""Sleep 1 second before calling the function"""

@functools.wraps(func)

def wrapper_slow_down(*args, **kwargs):

time.sleep(1)

return func(*args, **kwargs)

return wrapper_slow_down

def register(func):

"""Register a function as a plug-in"""

PLUGINS[func.__name__] = func

return func

def repeat(_func=None, *, num_times=2):

"""Run the decorated function the given number of times"""

def decorator_repeat(func):

@functools.wraps(func)

def wrapper_repeat(*args, **kwargs):

for _ in range(num_times):

value = func(*args, **kwargs)

return value

return wrapper_repeat

if _func is None:

return decorator_repeat

else:

return decorator_repeat(_func)

def count_calls(func):

"""Count the number of calls made to the decorated function"""

@functools.wraps(func)

def wrapper_count_calls(*args, **kwargs):

wrapper_count_calls.num_calls += 1

print(f"Call {wrapper_count_calls.num_calls} of {func.__name__!r}")

return func(*args, **kwargs)

wrapper_count_calls.num_calls = 0

return wrapper_count_calls

class CountCalls:

"""Count the number of calls made to the decorated function"""

def __init__(self, func):

functools.update_wrapper(self, func)

self.func = func

self.num_calls = 0

def __call__(self, *args, **kwargs):

self.num_calls += 1

print(f"Call {self.num_calls} of {self.func.__name__!r}")

return self.func(*args, **kwargs)

def slow_down(_func=None, *, rate=1):

"""Sleep given amount of seconds before calling the function"""

def decorator_slow_down(func):

@functools.wraps(func)

def wrapper_slow_down(*args, **kwargs):

time.sleep(rate)

return func(*args, **kwargs)

return wrapper_slow_down

if _func is None:

return decorator_slow_down

else:

return decorator_slow_down(_func)

def singleton(cls):

"""Make a class a Singleton class (only one instance)"""

@functools.wraps(cls)

def wrapper_singleton(*args, **kwargs):

if not wrapper_singleton.instance:

wrapper_singleton.instance = cls(*args, **kwargs)

return wrapper_singleton.instance

wrapper_singleton.instance = None

return wrapper_singleton

def cache(func):

"""Keep a cache of previous function calls"""

@functools.wraps(func)

def wrapper_cache(*args, **kwargs):

cache_key = args + tuple(kwargs.items())

if cache_key not in wrapper_cache.cache:

wrapper_cache.cache[cache_key] = func(*args, **kwargs)

return wrapper_cache.cache[cache_key]

wrapper_cache.cache = dict()

return wrapper_cache

def set_unit(unit):

"""Register a unit on a function"""

def decorator_set_unit(func):

func.unit = unit

return func

return decorator_set_unit