def _check_params(self, parameters):
"""Checks for mistakes in 'parameters'
Args :
parameters: dict, parameters to be checked
Raises :
ValueError: if any parameter is not a valid argument for the target function
or the target function is not defined
TypeError: if argument parameters is not iterable
"""
a_valid_fn = []
if self.target_fn is None:
if callable(self):
a_valid_fn.append(self.__call__)
else:
raise TypeError('invalid argument: tested object is not callable,\
please provide a valid target_fn')
elif isinstance(self.target_fn, types.FunctionType) \
or isinstance(self.target_fn, types.MethodType):
a_valid_fn.append(self.target_fn)
else:
a_valid_fn.append(self.target_fn.__call__)
if not isinstance(parameters, str):
for p in parameters:
for fn in a_valid_fn:
if has_arg(fn, p):
pass
else:
raise ValueError('{} is not a valid parameter'.format(p))
else:
raise TypeError('invalid argument: list or dictionnary expected')
def _check_params(self, parameters):
"""Checks for mistakes in 'parameters'
Args :
parameters: dict, parameters to be checked
Raises :
ValueError: if any parameter is not a valid argument for the target function
or the target function is not defined
TypeError: if argument parameters is not iterable
"""
a_valid_fn = []
if self.target_fn is None:
if callable(self):
a_valid_fn.append(self.__call__)
else:
raise TypeError(
'invalid argument: tested object is not callable,\
please provide a valid target_fn')
elif isinstance(self.target_fn, types.FunctionType) \
or isinstance(self.target_fn, types.MethodType):
a_valid_fn.append(self.target_fn)
else:
a_valid_fn.append(self.target_fn.__call__)
if not isinstance(parameters, str):
for p in parameters:
for fn in a_valid_fn:
if has_arg(fn, p):
pass
else:
raise ValueError(
'{} is not a valid parameter'.format(p))
else:
raise TypeError('invalid argument: list or dictionnary expected')
def filter_params(self, fn, override=None):
"""Filters `target_params` and return those in `fn`'s arguments.
Args:
fn : arbitrary function
override: dict, values to override target_params
Returns:
result : dict, dictionary containing variables
in both target_params and fn's arguments.
"""
override = override or {}
result = {}
for name, value in self.target_params.items():
if has_arg(fn, name):
result.update({name: value})
result.update(override)
return result
def filter_params(self, fn, override=None):
"""Filters `target_params` and return those in `fn`'s arguments.
Args:
fn : arbitrary function
override: dict, values to override target_params
Returns:
result : dict, dictionary containing variables
in both target_params and fn's arguments.
"""
override = override or {}
result = {}
for name, value in self.target_params.items():
if has_arg(fn, name):
result.update({name: value})
result.update(override)
return result
def _check_params(self, parameters):
a_valid_fn = []
if self.target_fn is None:
if callable(self):
a_valid_fn.append(self.__call__)
else:
raise TypeError('invalid argument: tested object is not callable')
elif isinstance(self.target_fn, types.FunctionType) \
or isinstance(self.target_fn, types.MethodType):
a_valid_fn.append(self.target_fn)
else:
a_valid_fn.append(self.target_fn.__call__)
if not isinstance(parameters, str):
for p in parameters:
for fn in a_valid_fn:
if has_arg(fn, p):
pass
else:
raise ValueError('{} is not a valid parameter'.format(p))
else:
raise TypeError('invalid argument: list or dictionary expected')
def test_has_arg(self):
# fn is callable / is not callable
class FooNotCallable:
def __init__(self, word):
self.message = word
class FooCallable:
def __init__(self, word):
self.message = word
def __call__(self, message):
return message
def positional_argument_call(self, arg1):
return self.message
def multiple_positional_arguments_call(self, *args):
res = []
for a in args:
res.append(a)
return res
def keyword_argument_call(self, filter_=True):
res = self.message
if filter_:
res = 'KO'
return res
def multiple_keyword_arguments_call(self, arg1='1', arg2='2'):
return self.message + arg1 + arg2
def undefined_keyword_arguments_call(self, **kwargs):
res = self.message
for a in kwargs:
res = res + a
return a
foo_callable = FooCallable('OK')
self.assertTrue(has_arg(foo_callable, 'message'))
if sys.version_info < (3,):
foo_not_callable = FooNotCallable('KO')
self.assertFalse(has_arg(foo_not_callable, 'message'))
elif sys.version_info < (3, 6):
with self.assertRaises(TypeError):
foo_not_callable = FooNotCallable('KO')
has_arg(foo_not_callable, 'message')
# Python 2, argument in / not in valid arguments / keyword arguments
if sys.version_info < (3,):
self.assertFalse(has_arg(foo_callable, 'invalid_arg'))
self.assertTrue(has_arg(foo_callable.positional_argument_call, 'arg1'))
self.assertFalse(has_arg(foo_callable.multiple_positional_arguments_call, 'argX'))
self.assertFalse(has_arg(foo_callable.keyword_argument_call, 'argX'))
self.assertTrue(has_arg(foo_callable.keyword_argument_call, 'filter_'))
self.assertTrue(has_arg(foo_callable.multiple_keyword_arguments_call, 'arg2'))
self.assertFalse(has_arg(foo_callable.multiple_keyword_arguments_call, 'arg3'))
self.assertFalse(has_arg(foo_callable.undefined_keyword_arguments_call, 'argX'))
# Python 3, argument in / not in valid arguments / keyword arguments
elif sys.version_info < (3, 6):
self.assertFalse(has_arg(foo_callable, 'invalid_arg'))
self.assertTrue(has_arg(foo_callable.positional_argument_call, 'arg1'))
self.assertFalse(has_arg(foo_callable.multiple_positional_arguments_call, 'argX'))
self.assertFalse(has_arg(foo_callable.keyword_argument_call, 'argX'))
self.assertTrue(has_arg(foo_callable.keyword_argument_call, 'filter_'))
self.assertTrue(has_arg(foo_callable.multiple_keyword_arguments_call, 'arg2'))
self.assertFalse(has_arg(foo_callable.multiple_keyword_arguments_call, 'arg3'))
self.assertFalse(has_arg(foo_callable.undefined_keyword_arguments_call, 'argX'))
else:
self.assertFalse(has_arg(foo_callable, 'invalid_arg'))
self.assertTrue(has_arg(foo_callable.positional_argument_call, 'arg1'))
self.assertFalse(has_arg(foo_callable.multiple_positional_arguments_call, 'argX'))
self.assertFalse(has_arg(foo_callable.keyword_argument_call, 'argX'))
self.assertTrue(has_arg(foo_callable.keyword_argument_call, 'filter_'))
self.assertTrue(has_arg(foo_callable.multiple_keyword_arguments_call, 'arg2'))
self.assertFalse(has_arg(foo_callable.multiple_keyword_arguments_call, 'arg3'))
self.assertFalse(has_arg(foo_callable.undefined_keyword_arguments_call, 'argX'))
# argname is None
self.assertFalse(has_arg(foo_callable, None))
pass
else:
raise ValueError('{} is not a valid parameter'.format(p))
else:
raise TypeError('invalid argument: list or dictionary expected')
def set_params(self, **params):
self._check_params(params)
self.target_params = params
def filter_params(self, fn, override=None):
de = override or {}
result = {}
for name, value in self.target_params.items():
if has_arg(fn, name):
result.update({name: value})
result.update(override)
return result
class Segmentation(BaseWrapper):
def __init__(self, algo_type, **target_params):
self.algo_type = algo_type
if (self.algo_type == 'quickshift'):
BaseWrapper.__init__(self, quickshift, **target_params)
kwargs = self.filter_params(quickshift)
self.set_params(**kwargs)
elif (self.algo_type == 'felzenszwalb'):
BaseWrapper.__init__(self, felzenszwalb, **target_params)
def test_has_arg(self):
# fn is callable / is not callable
class FooNotCallable:
def __init__(self, word):
self.message = word
class FooCallable:
def __init__(self, word):
self.message = word
def __call__(self, message):
return message
def positional_argument_call(self, arg1):
return self.message
def multiple_positional_arguments_call(self, *args):
res = []
for a in args:
res.append(a)
return res
def keyword_argument_call(self, filter_=True):
res = self.message
if filter_:
res = 'KO'
return res
def multiple_keyword_arguments_call(self, arg1='1', arg2='2'):
return self.message + arg1 + arg2
def undefined_keyword_arguments_call(self, **kwargs):
res = self.message
for a in kwargs:
res = res + a
return a
foo_callable = FooCallable('OK')
self.assertTrue(has_arg(foo_callable, 'message'))
if sys.version_info < (3, ):
foo_not_callable = FooNotCallable('KO')
self.assertFalse(has_arg(foo_not_callable, 'message'))
elif sys.version_info < (3, 6):
with self.assertRaises(TypeError):
foo_not_callable = FooNotCallable('KO')
has_arg(foo_not_callable, 'message')
# Python 2, argument in / not in valid arguments / keyword arguments
if sys.version_info < (3, ):
self.assertFalse(has_arg(foo_callable, 'invalid_arg'))
self.assertTrue(
has_arg(foo_callable.positional_argument_call, 'arg1'))
self.assertFalse(
has_arg(foo_callable.multiple_positional_arguments_call,
'argX'))
self.assertFalse(
has_arg(foo_callable.keyword_argument_call, 'argX'))
self.assertTrue(
has_arg(foo_callable.keyword_argument_call, 'filter_'))
self.assertTrue(
has_arg(foo_callable.multiple_keyword_arguments_call, 'arg2'))
self.assertFalse(
has_arg(foo_callable.multiple_keyword_arguments_call, 'arg3'))
self.assertFalse(
has_arg(foo_callable.undefined_keyword_arguments_call, 'argX'))
# Python 3, argument in / not in valid arguments / keyword arguments
elif sys.version_info < (3, 6):
self.assertFalse(has_arg(foo_callable, 'invalid_arg'))
self.assertTrue(
has_arg(foo_callable.positional_argument_call, 'arg1'))
self.assertFalse(
has_arg(foo_callable.multiple_positional_arguments_call,
'argX'))
self.assertFalse(
has_arg(foo_callable.keyword_argument_call, 'argX'))
self.assertTrue(
has_arg(foo_callable.keyword_argument_call, 'filter_'))
self.assertTrue(
has_arg(foo_callable.multiple_keyword_arguments_call, 'arg2'))
self.assertFalse(
has_arg(foo_callable.multiple_keyword_arguments_call, 'arg3'))
self.assertFalse(
has_arg(foo_callable.undefined_keyword_arguments_call, 'argX'))
else:
self.assertFalse(has_arg(foo_callable, 'invalid_arg'))
self.assertTrue(
has_arg(foo_callable.positional_argument_call, 'arg1'))
self.assertFalse(
has_arg(foo_callable.multiple_positional_arguments_call,
'argX'))
self.assertFalse(
has_arg(foo_callable.keyword_argument_call, 'argX'))
self.assertTrue(
has_arg(foo_callable.keyword_argument_call, 'filter_'))
self.assertTrue(
has_arg(foo_callable.multiple_keyword_arguments_call, 'arg2'))
self.assertFalse(
has_arg(foo_callable.multiple_keyword_arguments_call, 'arg3'))
self.assertFalse(
has_arg(foo_callable.undefined_keyword_arguments_call, 'argX'))
# argname is None
self.assertFalse(has_arg(foo_callable, None))
