def check_all(f, args, kwargs, checks, is_method):
spec = getargspec(f)
name = f.__name__
arg_names = []
args_to_check = []
# strip the first argument if is_method is true (this is the self parameter)
if is_method:
if not (len(args) > 0 and isinstance(args[0], object)):
raise RuntimeError(
'%s: no class found as first argument. Use typecheck instead of typecheck_method?'
% name)
arg_names.extend(spec.args[1:])
args_to_check.extend(args[1:])
else:
arg_names.extend(spec.args)
args_to_check.extend(args)
# if f has varargs, tuple any unnamed args and pass that as a regular argument to the checker
if spec.varargs:
n_named_args = len(spec.args) - (1 if is_method else 0)
tupled_varargs = tuple(args_to_check[n_named_args:])
args_to_check = args_to_check[:n_named_args]
args_to_check.append(tupled_varargs)
arg_names.append(spec.varargs)
# if f has varkw, pass them as a dict to the checker.
if spec.varkw:
args_to_check.append(kwargs)
arg_names.append(spec.varkw)
# ensure that the typecheck signature is appropriate and matches the function signature
if set(arg_names) != set(checks.keys()):
unmatched_tc = [k for k in checks if k not in arg_names]
unmatched_f = [k for k in arg_names if k not in checks]
if unmatched_f or unmatched_tc:
msg = ''
if unmatched_tc:
msg += 'unmatched typecheck arguments: %s' % unmatched_tc
if unmatched_f:
if msg:
msg += ', and '
msg += 'function parameters with no defined type: %s' % unmatched_f
raise RuntimeError('%s: invalid typecheck signature: %s' %
(name, msg))
# type check the function arguments
for argname, arg in zip(arg_names, args_to_check):
tc = only(checks[argname])
if not tc.check(arg):
raise TypeError(
"%s: parameter '%s': expected %s, found %s: '%s'" %
(name, argname, tc.expects(), extract(type(arg)), str(arg)))
def check_all(f, args, kwargs, checks, is_method):
spec = getargspec(f)
name = f.__name__
arg_names = []
args_to_check = []
# strip the first argument if is_method is true (this is the self parameter)
if is_method:
if not (len(args) > 0 and isinstance(args[0], object)):
raise RuntimeError(
'%s: no class found as first argument. Use typecheck instead of typecheck_method?' % name)
arg_names.extend(spec.args[1:])
args_to_check.extend(args[1:])
else:
arg_names.extend(spec.args)
args_to_check.extend(args)
# if f has varargs, tuple any unnamed args and pass that as a regular argument to the checker
if spec.varargs:
n_named_args = len(spec.args) - (1 if is_method else 0)
tupled_varargs = tuple(args_to_check[n_named_args:])
args_to_check = args_to_check[:n_named_args]
args_to_check.append(tupled_varargs)
arg_names.append(spec.varargs)
# if f has varkw, pass them as a dict to the checker.
if spec.varkw:
args_to_check.append(kwargs)
arg_names.append(spec.varkw)
# ensure that the typecheck signature is appropriate and matches the function signature
if set(arg_names) != set(checks.keys()):
unmatched_tc = [k for k in checks if k not in arg_names]
unmatched_f = [k for k in arg_names if k not in checks]
if unmatched_f or unmatched_tc:
msg = ''
if unmatched_tc:
msg += 'unmatched typecheck arguments: %s' % unmatched_tc
if unmatched_f:
if msg:
msg += ', and '
msg += 'function parameters with no defined type: %s' % unmatched_f
raise RuntimeError('%s: invalid typecheck signature: %s' % (name, msg))
# type check the function arguments
for argname, arg in zip(arg_names, args_to_check):
tc = only(checks[argname])
if not tc.check(arg):
raise TypeError("%s: parameter '%s': expected %s, found %s: '%s'" %
(name, argname, tc.expects(), extract(type(arg)), str(arg)))
def _verify_axis(func, *args, **kwargs):
# get the axis argument to check
all_args = getargspec(func)[0]
ax_index = all_args.index(axis)
a_edit = kwargs.get(axis, args[ax_index])
if a_edit is None: return func(*args, **kwargs)
if not isinstance(a_edit, list): a_edit = [a_edit]
# ckeck the axis
valid_ax = ['x', 'y']
not_supported = [ax for ax in a_edit if not ax in valid_ax]
if not_supported:
msg = "{} is not a valid axis! Supported are: {}"
raise ValueError(msg.format(not_supported, valid_ax))
return func(*args, **kwargs)
def _to_list(func, *args, **kwargs):
all_args = getargspec(func)[0]
for val in to_list:
# get the arguments to modify
val_index = all_args.index(val)
v = kwargs.get(val, args[val_index])
if v is None: v = []
if not isinstance(v, list): v = [v]
if kwargs.get(val):
kwargs[val] = v
else:
args = tuple(a if not x == val_index else v
for x, a in enumerate(args))
return func(*args, **kwargs)
def _verify_text_key(func, *args, **kwargs):
all_args = getargspec(func)[0]
ds = args[0]
for text_key in text_keys:
# get the text_key argument to check
tk_index = all_args.index(text_key)
tks = kwargs.get(text_key, args[tk_index])
if tks is None: return func(*args, **kwargs)
if not isinstance(tks, list): tks = [tks]
# ckeck the text_key
valid_tks = ds.valid_tks
not_supported = [tk for tk in tks if not tk in valid_tks]
if not_supported:
msg = "{} is not a valid text_key! Supported are: \n {}"
raise ValueError(msg.format(not_supported, valid_tks))
return func(*args, **kwargs)
def _var_is_cat(func, *args, **kwargs):
all_args = getargspec(func)[0]
ds = args[0]
for cat in categorical:
# get the variable argument to check if it is categorical
v_index = all_args.index(cat)
var = kwargs.get(cat, args[v_index])
if var is None: return func(*args, **kwargs)
if not isinstance(var, list): var = [var]
var = [v for v in var if not v == '@']
# check if varaibles are categorical
not_cat = [v for v in var if not ds._has_categorical_data(v)]
if not_cat:
msg = "'{}' argument for {}() must reference categorical "
msg += 'variable.\n {} is not categorical.'
msg = msg.format(cat, func.func_name, not_cat)
raise ValueError(msg)
return func(*args, **kwargs)
def decorated(func, *args):
"""Validates arguments given schemas."""
# decorator.decorator swallows kwargs for some reason.
argspec = decorator.getargspec(func)
defaults = []
if argspec.defaults:
defaults = argspec.defaults
kwargs = {}
for kw_name, kw_value, kw_default in zip(reversed(argspec.args),
reversed(args), defaults):
if kw_value != kw_default:
kwargs[kw_name] = kw_value
if len(defaults):
args = list(args)[:-len(defaults)]
else:
args = list(args)
valid_args, valid_kwargs = validate(args, kwargs)
if not _TEST_MODE:
return func(*valid_args, **valid_kwargs)
def _var_in_ds(func, *args, **kwargs):
all_args = getargspec(func)[0]
ds = args[0]
for variable, collection in variables.items():
# get collection for argument
if collection == 'both':
collection = ['columns', 'masks']
else:
collection = [collection]
c = [key for col in collection for key in ds._meta[col].keys()]
# get the variable argument to check
v_index = all_args.index(variable)
var = kwargs.get(variable, args[v_index])
if var is None: return func(*args, **kwargs)
if not isinstance(var, list): var = [var]
# check the variable
not_valid = [v for v in var if not v in c + ['@']]
if not_valid:
msg = "'{}' argument for {}() must be in {}.\n"
msg += '{} is not in {}.'
msg = msg.format(variable, func.func_name, collection,
not_valid, collection)
raise ValueError(msg)
return func(*args, **kwargs)
def check_all(f, args, kwargs, checks, is_method):
spec = getargspec(f)
name = f.__name__
args_ = []
# strip the first argument if is_method is true (this is the self parameter)
if is_method:
if not (len(args) > 0 and isinstance(args[0], object)):
raise RuntimeError(
'%s: no class found as first argument. Use typecheck instead of typecheck_method?'
% name)
named_args = spec.args[1:]
pos_args = args[1:]
args_.append(args[0])
else:
named_args = spec.args[:]
pos_args = args[:]
signature_namespace = set(named_args).union(
set(filter(lambda x: x is not None, [spec.varargs, spec.varkw])))
tc_namespace = set(checks.keys())
# ensure that the typecheck signature is appropriate and matches the function signature
if signature_namespace != tc_namespace:
unmatched_tc = list(tc_namespace - signature_namespace)
unmatched_sig = list(signature_namespace - tc_namespace)
if unmatched_sig or unmatched_tc:
msg = ''
if unmatched_tc:
msg += 'unmatched typecheck arguments: %s' % unmatched_tc
if unmatched_sig:
if msg:
msg += ', and '
msg += 'function parameters with no defined type: %s' % unmatched_sig
raise RuntimeError('%s: invalid typecheck signature: %s' %
(name, msg))
for i in range(len(pos_args)):
arg = pos_args[i]
argname = named_args[i] if i < len(named_args) else spec.varargs
tc = checks[argname]
try:
arg_ = tc.check(arg)
args_.append(arg_)
except TypecheckFailure:
if i < len(named_args):
raise TypeError(
"{fname}: parameter '{argname}': "
"expected {expected}, found {found}: '{arg}'".format(
fname=name,
argname=argname,
expected=tc.expects(),
found=extract(type(arg)),
arg=str(arg)))
else:
raise TypeError(
"{fname}: parameter '*{argname}' (arg {idx} of {tot}): "
"expected {expected}, found {found}: '{arg}'".format(
fname=name,
argname=argname,
idx=i - len(named_args),
tot=len(pos_args) - len(named_args),
expected=tc.expects(),
found=extract(type(arg)),
arg=str(arg)))
kwargs_ = {}
if spec.varkw:
tc = checks[spec.varkw]
for argname, arg in kwargs.items():
try:
arg_ = tc.check(arg)
kwargs_[argname] = arg_
except TypecheckFailure:
raise TypeError(
"{fname}: keyword argument '{argname}': "
"expected {expected}, found {found}: '{arg}'".format(
fname=name,
argname=argname,
expected=tc.expects(),
found=extract(type(arg)),
arg=str(arg)))
return args_, kwargs_
def make_command(parent, name, func):
"""Make a command using reflection on the function."""
# Disable "Too many branches" warning.
#
# pylint: disable=R0912
argspec = decorator.getargspec(func)
args = list(argspec.args)
defaults = argspec.defaults
if defaults is None:
defaults = []
else:
defaults = list(defaults)
@parent.command(name=name, help=func.__doc__)
def command(*args, **kwargs):
"""Constructs a command handler."""
try:
if 'rsrc' in kwargs:
kwargs['rsrc'] = yaml.load(kwargs['rsrc'].read())
formatter = cli.make_formatter(None)
cli.out(formatter(func(*args, **kwargs)))
except jsonschema.exceptions.ValidationError as input_err:
click.echo(input_err, err=True)
except jsonschema.exceptions.RefResolutionError as res_error:
click.echo(res_error, err=True)
except authz.AuthorizationError as auth_err:
click.echo('Not authorized.', err=True)
click.echo(auth_err, err=True)
except TypeError as type_err:
click.echo(type_err, err=True)
while defaults:
arg = args.pop()
defarg = defaults.pop()
if defarg is not None:
argtype = type(defarg)
else:
argtype = str
if defarg == ():
# redefinition of the type from tuple to list.
argtype = cli.LIST # pylint: disable=R0204
defarg = None
click.option('--' + arg, default=defarg, type=argtype)(command)
if not args:
return
arg = args.pop(0)
click.argument(arg)(command)
while args:
if len(args) == 1:
arg = args.pop(0)
click.argument(arg, type=click.File('rb'))(command)
else:
arg = args.pop(0)
click.argument(arg)(command)
if args:
raise click.UsageError('Non-standard API: %s, %r' % (name, argspec))