"""smart_default_arguments module"""
import inspect
# mutable default arguments
def recalculate_defaults(f, newdefaults):
argspec = inspect.getfullargspec(f)
# take care of defaults
args = argspec.args
defaults = list(argspec.defaults)
num_bare_args = len(args) - len(defaults)
for i in range(len(args)-num_bare_args):
defaults[i] = newdefaults.pop(args[i+num_bare_args], defaults[i])
bare_args = args[:num_bare_args]
while bare_args:
arg = bare_args.pop()
if arg in newdefaults:
defaults = [newdefaults.pop(arg)] + defaults
else:
break
# take care of kwonly defaults
kwonly = argspec.kwonlyargs[:]
kwdefaults = argspec.kwonlydefaults
num_bare_kwonly = len(kwonly) - len(kwdefaults or ())
for arg in kwonly[num_bare_kwonly:]:
kwdefaults[arg] = newdefaults.pop(arg, kwdefaults[arg])
bare_kwonly = kwonly[:num_bare_kwonly]
while bare_kwonly:
arg = bare_kwonly.pop()
if arg in newdefaults:
kwdefaults[arg] = newdefaults.pop(arg)
else:
break
# finish up
if newdefaults:
raise TypeError("Unexpected new defaults: %s" % newdefaults)
return tuple(defaults), kwdefaults
def has_default_arguments(**kwargs):
"""A decorator factory that applies default arguments.
It handles mutable default arguments, which sets it apart from the
normal handling of default arguments.
Trust that kwargs matches parameters of the decorated function.
"""
def decorator(f):
f.__defaults__, f.__kwdefaults__ = recalculate_defaults(f, kwargs)
return f
return decorator
# deferred default arguments
import functools
class DEFER_DEFAULT_TYPE:
"""Indicates that the default argument should be deferred to the callee."""
DEFERRED = DEFER_DEFAULT_TYPE()
ERROR_MSG = "A DEFERRED object cannot be used for a non-default argument"
def recalculate_arguments(args, kwargs, f):
argspec = inspect.getfullargspec(f)
args = list(args)
spec_args = argspec.args
defaults = argspec.defaults
num_args = len(args)
num_bare_args = len(spec_args) - len(defaults)
# handle argspec.args
for i in range(len(spec_args)):
arg = spec_args[i]
if i >= num_bare_args:
if i < num_args and args[i] is DEFERRED:
args[i] = defaults[i-num_bare_args]
elif kwargs.get(arg) is DEFERRED:
kwargs[arg] = defaults[i-num_bare_args]
continue
if i < num_args and args[i] is DEFERRED:
raise TypeError(ERROR_MSG)
elif kwargs.get(arg) is DEFERRED:
raise TypeError(ERROR_MSG)
# handle argspec.kwonlyargs
defaults = argspec.kwonlydefaults
for arg in argspec.kwonlyargs:
if kwargs[arg] != DEFERRED:
continue
if arg not in kwonlydefaults:
raise TypeError(ERROR_MSG)
kwargs[arg] = kwonlydefaults[arg]
return args, kwargs
def accepts_deferred_defaults(f):
@functools.wraps(f)
def newfunc(*args, **kwargs):
args, kwargs = recalculate_arguments(args, kwargs, f)
return f(*args, **kwargs)
return newfunc
