from tiramisu.setting import groups
from tiramisu.config import Config
from tiramisu.option import ChoiceOption, BoolOption, IntOption, FloatOption, \
- StrOption, OptionDescription
+ StrOption, OptionDescription, SymLinkOption
from tiramisu.error import PropertiesOptionError, ConflictError, SlaveError, ConfigError
return 'val'
-def return_list():
+def return_concat(*args):
+ return '.'.join(list(args))
+
+
+def return_list(value=None):
return ['val', 'val']
-def return_value(value):
+def return_list2(*args):
+ return list(args)
+
+
+def return_value(value=None):
return value
def test_callback_value():
val1 = StrOption('val1', "", 'val')
- val2 = StrOption('val2', "", callback=return_value, callback_params={'': (('val1', False),)})
- maconfig = OptionDescription('rootconfig', '', [val1, val2])
+ val2 = StrOption('val2', "", callback=return_value, callback_params={'': ((val1, False),)})
+ val3 = StrOption('val3', "", callback=return_value, callback_params={'': ('yes',)})
+ val4 = StrOption('val4', "", callback=return_value, callback_params={'value': ((val1, False),)})
+ val5 = StrOption('val5', "", callback=return_value, callback_params={'value': ('yes',)})
+ maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4, val5])
cfg = Config(maconfig)
cfg.read_write()
assert cfg.val1 == 'val'
assert cfg.val2 == 'val'
+ assert cfg.val4 == 'val'
cfg.val1 = 'new-val'
assert cfg.val1 == 'new-val'
assert cfg.val2 == 'new-val'
+ assert cfg.val4 == 'new-val'
del(cfg.val1)
assert cfg.val1 == 'val'
assert cfg.val2 == 'val'
+ assert cfg.val3 == 'yes'
+ assert cfg.val4 == 'val'
+ assert cfg.val5 == 'yes'
+
+
+def test_callback_value_tuple():
+ val1 = StrOption('val1', "", 'val1')
+ val2 = StrOption('val2', "", 'val2')
+ val3 = StrOption('val3', "", callback=return_concat, callback_params={'': ((val1, False), (val2, False))})
+ val4 = StrOption('val4', "", callback=return_concat, callback_params={'': ('yes', 'no')})
+ raises(ValueError, "StrOption('val4', '', callback=return_concat, callback_params={'value': ('yes', 'no')})")
+ maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4])
+ cfg = Config(maconfig)
+ cfg.read_write()
+ assert cfg.val1 == 'val1'
+ assert cfg.val2 == 'val2'
+ assert cfg.val3 == 'val1.val2'
+ assert cfg.val4 == 'yes.no'
+ cfg.val1 = 'new-val'
+ assert cfg.val3 == 'new-val.val2'
+ del(cfg.val1)
+ assert cfg.val3 == 'val1.val2'
+
+
+def test_callback_value_force_permissive():
+ val1 = StrOption('val1', "", 'val', properties=('disabled',))
+ val2 = StrOption('val2', "", callback=return_value, callback_params={'': ((val1, False),)})
+ val3 = StrOption('val3', "", callback=return_value, callback_params={'': ((val1, True),)})
+ maconfig = OptionDescription('rootconfig', '', [val1, val2, val3])
+ cfg = Config(maconfig)
+ cfg.read_only()
+ raises(ConfigError, "cfg.val2")
+ assert cfg.val3 is None
+
+
+def test_callback_symlink():
+ val1 = StrOption('val1', "", 'val')
+ val2 = SymLinkOption('val2', val1)
+ val3 = StrOption('val3', "", callback=return_value, callback_params={'': ((val2, False),)})
+ maconfig = OptionDescription('rootconfig', '', [val1, val2, val3])
+ cfg = Config(maconfig)
+ cfg.read_write()
+ assert cfg.val1 == 'val'
+ assert cfg.val3 == 'val'
+ cfg.val1 = 'new-val'
+ assert cfg.val1 == 'new-val'
+ assert cfg.val3 == 'new-val'
+ del(cfg.val1)
+ assert cfg.val1 == 'val'
+ assert cfg.val3 == 'val'
def test_callback_list():
def test_callback_multi_value():
val1 = StrOption('val1', "", ['val'], multi=True)
- val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params={'': (('val1', False),)})
- maconfig = OptionDescription('rootconfig', '', [val1, val2])
+ val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params={'': ((val1, False),)})
+ val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params={'': ('yes',)})
+ val4 = StrOption('val4', "", multi=True, callback=return_list2, callback_params={'': ((val1, False), 'yes')})
+ maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4])
cfg = Config(maconfig)
cfg.read_write()
assert cfg.val1 == ['val']
assert cfg.val2 == ['val']
+ assert cfg.val4 == ['val', 'yes']
cfg.val1 = ['new-val']
assert cfg.val1 == ['new-val']
assert cfg.val2 == ['new-val']
+ assert cfg.val4 == ['new-val', 'yes']
cfg.val1.append('new-val2')
assert cfg.val1 == ['new-val', 'new-val2']
assert cfg.val2 == ['new-val', 'new-val2']
+ assert cfg.val4 == ['new-val', 'yes', 'new-val2', 'yes']
del(cfg.val1)
assert cfg.val1 == ['val']
assert cfg.val2 == ['val']
+ assert cfg.val3 == ['yes']
+ assert cfg.val4 == ['val', 'yes']
def test_callback_multi_list():
def test_callback_master_and_slaves_value():
val1 = StrOption('val1', "", multi=True)
- val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params={'': (('val1.val1', False),)})
- interface1 = OptionDescription('val1', '', [val1, val2])
+ val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params={'': ((val1, False),)})
+ val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params={'': ('yes',)})
+ val4 = StrOption('val4', '', multi=True, default=['val10', 'val11'])
+ val5 = StrOption('val5', "", multi=True, callback=return_value, callback_params={'': ((val4, False),)})
+ interface1 = OptionDescription('val1', '', [val1, val2, val3, val5])
interface1.impl_set_group_type(groups.master)
- maconfig = OptionDescription('rootconfig', '', [interface1])
+ maconfig = OptionDescription('rootconfig', '', [interface1, val4])
cfg = Config(maconfig)
cfg.read_write()
assert cfg.val1.val1 == []
assert cfg.val1.val2 == []
+ assert cfg.val1.val3 == []
+ assert cfg.val1.val5 == []
#
cfg.val1.val1 = ['val1']
assert cfg.val1.val1 == ['val1']
assert cfg.val1.val2 == ['val1']
+ assert cfg.val1.val3 == ['yes']
+ assert cfg.val1.val5 == ['val10']
#
cfg.val1.val1.append('val2')
assert cfg.val1.val1 == ['val1', 'val2']
assert cfg.val1.val2 == ['val1', 'val2']
+ assert cfg.val1.val3 == ['yes', 'yes']
+ assert cfg.val1.val5 == ['val10', 'val11']
#
cfg.val1.val1 = ['val1', 'val2', 'val3']
assert cfg.val1.val1 == ['val1', 'val2', 'val3']
assert cfg.val1.val2 == ['val1', 'val2', 'val3']
+ assert cfg.val1.val3 == ['yes', 'yes', 'yes']
+ assert cfg.val1.val5 == ['val10', 'val11', None]
#
cfg.val1.val1.pop(2)
assert cfg.val1.val1 == ['val1', 'val2']
assert cfg.val1.val2 == ['val1', 'val2']
+ assert cfg.val1.val3 == ['yes', 'yes']
+ assert cfg.val1.val5 == ['val10', 'val11']
#
cfg.val1.val2 = ['val2', 'val2']
+ cfg.val1.val3 = ['val2', 'val2']
+ cfg.val1.val5 = ['val2', 'val2']
assert cfg.val1.val2 == ['val2', 'val2']
+ assert cfg.val1.val3 == ['val2', 'val2']
+ assert cfg.val1.val5 == ['val2', 'val2']
#
cfg.val1.val1.append('val3')
assert cfg.val1.val2 == ['val2', 'val2', 'val3']
+ assert cfg.val1.val3 == ['val2', 'val2', 'yes']
+ assert cfg.val1.val5 == ['val2', 'val2', None]
+ cfg.cfgimpl_get_settings().remove('cache')
+ cfg.val4 = ['val10', 'val11', 'val12']
+ #if value is already set, not updated !
+ cfg.val1.val1.pop(2)
+ cfg.val1.val1.append('val3')
+ cfg.val1.val1 = ['val1', 'val2', 'val3']
+ assert cfg.val1.val5 == ['val2', 'val2', 'val12']
def test_callback_hidden():
opt1 = BoolOption('opt1', '')
- opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': (('od1.opt1', False),)})
+ opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': ((opt1, False),)})
od1 = OptionDescription('od1', '', [opt1], properties=('hidden',))
od2 = OptionDescription('od2', '', [opt2])
maconfig = OptionDescription('rootconfig', '', [od1, od2])
def test_callback_two_disabled():
opt1 = BoolOption('opt1', '', properties=('disabled',))
- opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': (('od1.opt1', False),)}, properties=('disabled',))
+ opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': ((opt1, False),)}, properties=('disabled',))
od1 = OptionDescription('od1', '', [opt1])
od2 = OptionDescription('od2', '', [opt2])
maconfig = OptionDescription('rootconfig', '', [od1, od2])
def test_callback_calculating_disabled():
opt1 = BoolOption('opt1', '', properties=('disabled',))
- opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': (('od1.opt1', False),)})
+ opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': ((opt1, False),)})
od1 = OptionDescription('od1', '', [opt1])
od2 = OptionDescription('od2', '', [opt2])
maconfig = OptionDescription('rootconfig', '', [od1, od2])
def test_callback_calculating_mandatory():
opt1 = BoolOption('opt1', '', properties=('disabled',))
- opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': (('od1.opt1', False),)}, properties=('mandatory',))
+ opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': ((opt1, False),)}, properties=('mandatory',))
od1 = OptionDescription('od1', '', [opt1])
od2 = OptionDescription('od2', '', [opt2])
maconfig = OptionDescription('rootconfig', '', [od1, od2])
def test_callback_two_disabled_multi():
opt1 = BoolOption('opt1', '', properties=('disabled',))
- opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': (('od1.opt1', False),)}, properties=('disabled',), multi=True)
+ opt2 = BoolOption('opt2', '', callback=return_value, callback_params={'': ((opt1, False),)}, properties=('disabled',), multi=True)
od1 = OptionDescription('od1', '', [opt1])
od2 = OptionDescription('od2', '', [opt2])
maconfig = OptionDescription('rootconfig', '', [od1, od2])
cfg = Config(maconfig)
cfg.read_write()
raises(PropertiesOptionError, 'cfg.od2.opt2')
+
+
+def test_callback_multi_list_params():
+ val1 = StrOption('val1', "", multi=True, default=['val1', 'val2'])
+ val2 = StrOption('val2', "", multi=True, callback=return_list, callback_params={'': ((val1, False),)})
+ oval2 = OptionDescription('val2', '', [val2])
+ maconfig = OptionDescription('rootconfig', '', [val1, oval2])
+ cfg = Config(maconfig)
+ cfg.read_write()
+ assert cfg.val2.val2 == ['val', 'val', 'val', 'val']
+
+
+def test_callback_multi_list_params_key():
+ val1 = StrOption('val1', "", multi=True, default=['val1', 'val2'])
+ val2 = StrOption('val2', "", multi=True, callback=return_list, callback_params={'value': ((val1, False),)})
+ oval2 = OptionDescription('val2', '', [val2])
+ maconfig = OptionDescription('rootconfig', '', [val1, oval2])
+ cfg = Config(maconfig)
+ cfg.read_write()
+ assert cfg.val2.val2 == ['val', 'val', 'val', 'val']
+
+
+def test_callback_multi_multi():
+ val1 = StrOption('val1', "", multi=True, default=['val1', 'val2', 'val3'])
+ val2 = StrOption('val2', "", multi=True, default=['val11', 'val12'])
+ val3 = StrOption('val3', "", default='val4')
+ val4 = StrOption('val4', "", multi=True, callback=return_list2, callback_params={'': ((val1, False), (val2, False))})
+ val5 = StrOption('val5', "", multi=True, callback=return_list2, callback_params={'': ((val1, False), (val3, False))})
+ val6 = StrOption('val6', "", multi=True, default=['val21', 'val22', 'val23'])
+ val7 = StrOption('val7', "", multi=True, callback=return_list2, callback_params={'': ((val1, False), (val6, False))})
+ raises(ValueError, "StrOption('val8', '', multi=True, callback=return_list2, callback_params={'value': ((val1, False), (val6, False))})")
+ maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4, val5, val6, val7])
+ cfg = Config(maconfig)
+ cfg.read_write()
+ raises(ConfigError, "cfg.val4")
+ assert cfg.val5 == ['val1', 'val4', 'val2', 'val4', 'val3', 'val4']
+ assert cfg.val7 == ['val1', 'val21', 'val2', 'val22', 'val3', 'val23']
--- /dev/null
+import autopath
+from py.test import raises
+
+from tiramisu.config import Config
+from tiramisu.option import StrOption, OptionDescription
+from tiramisu.error import ConfigError
+
+
+def return_true(value, param=None):
+ if value == 'val' and param in [None, 'yes']:
+ return True
+
+
+def return_false(value, param=None):
+ if value == 'val' and param in [None, 'yes']:
+ return False
+
+
+def return_val(value, param=None):
+ return 'val'
+
+
+def test_validator():
+ opt1 = StrOption('opt1', '', validator=return_true, default='val')
+ raises(ValueError, "StrOption('opt2', '', validator=return_false, default='val')")
+ raises(ConfigError, "StrOption('opt3', '', validator=return_val, default='val')")
+ opt2 = StrOption('opt2', '', validator=return_false)
+ opt3 = StrOption('opt3', '', validator=return_val)
+ root = OptionDescription('root', '', [opt1, opt2, opt3])
+ cfg = Config(root)
+ assert cfg.opt1 == 'val'
+ raises(ValueError, "cfg.opt2 = 'val'")
+ raises(ConfigError, "cfg.opt3 = 'val'")
+
+
+def test_validator_params():
+ opt1 = StrOption('opt1', '', validator=return_true, validator_params={'': ('yes',)}, default='val')
+ raises(ValueError, "StrOption('opt2', '', validator=return_false, validator_params={'': ('yes',)}, default='val')")
+ raises(ConfigError, "StrOption('opt3', '', validator=return_val, validator_params={'': ('yes',)}, default='val')")
+ opt2 = StrOption('opt2', '', validator=return_false, validator_params={'': ('yes',)})
+ opt3 = StrOption('opt3', '', validator=return_val, validator_params={'': ('yes',)})
+ root = OptionDescription('root', '', [opt1, opt2, opt3])
+ cfg = Config(root)
+ assert cfg.opt1 == 'val'
+ raises(ValueError, "cfg.opt2 = 'val'")
+ raises(ConfigError, "cfg.opt3 = 'val'")
+
+
+def test_validator_params_key():
+ opt1 = StrOption('opt1', '', validator=return_true, validator_params={'param': ('yes',)}, default='val')
+ raises(TypeError, "StrOption('opt2', '', validator=return_true, validator_params={'param_unknown': ('yes',)}, default='val')")
+ root = OptionDescription('root', '', [opt1])
+ cfg = Config(root)
+ assert cfg.opt1 == 'val'
+
+
+def test_validator_params_option():
+ opt0 = StrOption('opt0', '', default='val')
+ raises(ValueError, "opt1 = StrOption('opt1', '', validator=return_true, validator_params={'': ((opt0, False),)}, default='val')")
from tiramisu.i18n import _
# ____________________________________________________________
-def carry_out_calculation(name,
- config,
- callback,
- callback_params,
- index=None):
+
+def carry_out_calculation(name, config, callback, callback_params,
+ index=None, max_len=None):
"""a function that carries out a calculation for an option's value
:param name: the option name (`opt._name`)
:type callback_params: dict
:param index: if an option is multi, only calculates the nth value
:type index: int
+ :param max_len: max length for a multi
+ :type max_len: int
+
+ * if no callback_params:
+ => calculate()
+
+ * if callback_params={'': ('yes',)}
+ => calculate('yes')
+
+ * if callback_params={'value': ('yes',)}
+ => calculate(value='yes')
+
+ * if callback_params={'': ('yes', 'no')}
+ => calculate('yes', 'no')
+
+ * if callback_params={'value': ('yes', 'no')}
+ => ValueError()
+
+ * if callback_params={'': ((opt1, False),)}
+
+ - a simple option:
+ opt1 == 11
+ => calculate(11)
+
+ - a multi option:
+ opt1 == [1, 2, 3]
+ => calculate(1)
+ => calculate(2)
+ => calculate(3)
+
+ * if callback_params={'value': ((opt1, False),)}
+
+ - a simple option:
+ opt1 == 11
+ => calculate(value=11)
+
+ - a multi option:
+ opt1 == [1, 2, 3]
+ => calculate(value=1)
+ => calculate(value=2)
+ => calculate(value=3)
+
+ * if callback_params={'': ((opt1, False), (opt2, False))}
+
+ - a multi option with a simple option
+ opt1 == [1, 2, 3]
+ opt2 == 11
+ => calculate(1, 11)
+ => calculate(2, 11)
+ => calculate(3, 11)
+
+ - a multi option with an other multi option but with same length
+ opt1 == [1, 2, 3]
+ opt2 == [11, 12, 13]
+ callback_params={'': ((opt1, False), (opt2, False))}
+ => calculate(1, 11)
+ => calculate(2, 12)
+ => calculate(3, 13)
+
+ - a multi option with an other multi option but with different length
+ opt1 == [1, 2, 3]
+ opt2 == [11, 12]
+ callback_params={'': ((opt1, False), (opt2, False))}
+ => ConfigError()
+
+ * if callback_params={'value': ((opt1, False), (opt2, False))}
+ => ConfigError()
+
+ If index is not None, return a value, otherwise return:
+
+ * a list if one parameters have multi option
+ * a value otherwise
+
+ If calculate return list, this list is extend to return value.
"""
- #callback, callback_params = option.getcallback()
- #if callback_params is None:
- # callback_params = {}
tcparams = {}
one_is_multi = False
len_multi = 0
- for key, values in callback_params.items():
- for value in values:
- if type(value) == tuple:
- path, check_disabled = value
- if config is None:
- if check_disabled:
- continue
- raise ConfigError(_('no config specified but needed'))
+ for key, callbacks in callback_params.items():
+ for callbk in callbacks:
+ if isinstance(callbk, tuple):
+ option, force_permissive = callbk
+ # get value
try:
- opt_value = config._getattr(path, force_permissive=True)
- opt = config.unwrap_from_path(path, force_permissive=True)
+ path = config.cfgimpl_get_description().impl_get_path_by_opt(option)
+ value = config._getattr(path, force_permissive=True)
except PropertiesOptionError as err:
- if check_disabled:
+ if force_permissive:
continue
raise ConfigError(_('unable to carry out a calculation, '
'option {0} has properties: {1} for: '
- '{2}').format(path, err.proptype,
+ '{2}').format(option._name, err.proptype,
name))
- is_multi = opt.impl_is_multi()
+ is_multi = option.impl_is_multi()
if is_multi:
- if opt_value is not None:
- len_value = len(opt_value)
+ if value is not None:
+ len_value = len(value)
if len_multi != 0 and len_multi != len_value:
raise ConfigError(_('unable to carry out a '
'calculation, option value with'
'length for: {0}').format(name))
len_multi = len_value
one_is_multi = True
- tcparams.setdefault(key, []).append((opt_value, is_multi))
+ tcparams.setdefault(key, []).append((value, is_multi))
else:
- tcparams.setdefault(key, []).append((value, False))
+ tcparams.setdefault(key, []).append((callbk, False))
if one_is_multi:
ret = []
if index:
- range_ = [index]
+ if index < len_multi:
+ range_ = [index]
+ else:
+ range_ = []
+ ret = None
else:
- range_ = range(len_multi)
+ if max_len and max_len < len_multi:
+ range_ = range(max_len)
+ else:
+ range_ = range(len_multi)
for incr in range_:
tcp = {}
params = []
if key == '':
params.append(value[incr])
else:
- if len(value) > incr:
- tcp[key] = value[incr]
- else:
- tcp[key] = ''
+ tcp[key] = value[incr]
else:
- if key == '':
- params.append(value)
- else:
- tcp[key] = value
+ params.append(value)
calc = calculate(name, callback, params, tcp)
if index:
ret = calc
ret.extend(calc)
else:
ret.append(calc)
-
return ret
else:
tcp = {}
def calculate(name, callback, params, tcparams):
- # FIXME we don't need the option's name down there.
"""wrapper that launches the 'callback'
:param callback: callback name
from types import FunctionType
from IPy import IP
-from tiramisu.error import ConflictError
+from tiramisu.error import ConflictError, ConfigError
from tiramisu.setting import groups, multitypes
from tiramisu.i18n import _
from tiramisu.autolib import carry_out_calculation
"frozen" (which has noting to do with the high level "freeze"
propertie or "read_only" property)
"""
- if not name.startswith('_state') and \
- name not in ('_cache_paths', '_consistencies'):
+ if not name.startswith('_state') and name not in ('_cache_paths',
+ '_consistencies'):
is_readonly = False
# never change _name
if name == '_name':
def __init__(self, name, doc, default=None, default_multi=None,
requires=None, multi=False, callback=None,
- callback_params=None, validator=None, validator_args=None,
+ callback_params=None, validator=None, validator_params=None,
properties=None):
"""
:param name: the option's name
:param callback_params: the callback's parameter
:param validator: the name of a function which stands for a custom
validation of the value
- :param validator_args: the validator's parameters
+ :param validator_params: the validator's parameters
:param properties: tuple of default properties
"""
super(Option, self).__init__(name, doc, requires, properties)
self._multi = multi
if validator is not None:
- if type(validator) != FunctionType:
- raise TypeError(_("validator must be a function"))
- if validator_args is None:
- validator_args = {}
- self._validator = (validator, validator_args)
+ validate_callback(validator, validator_params, 'validator')
+ self._validator = (validator, validator_params)
else:
self._validator = None
if not self._multi and default_multi is not None:
"no callback defined"
" yet for option {0}").format(name))
if callback is not None:
- if type(callback) != FunctionType:
- raise ValueError('callback must be a function')
- if callback_params is not None and \
- not isinstance(callback_params, dict):
- raise ValueError('callback_params must be a dict')
+ validate_callback(callback, callback_params, 'callback')
self._callback = (callback, callback_params)
else:
self._callback = None
def val_validator(val):
if self._validator is not None:
- callback_params = deepcopy(self._validator[1])
- callback_params.setdefault('', []).insert(0, val)
- return carry_out_calculation(self._name, config=context,
- callback=self._validator[0],
- callback_params=callback_params)
+ if self._validator[1] is not None:
+ validator_params = deepcopy(self._validator[1])
+ if '' in validator_params:
+ lst = list(validator_params[''])
+ lst.insert(0, val)
+ validator_params[''] = tuple(lst)
+ else:
+ validator_params[''] = (val,)
+ else:
+ validator_params = {'': (val,)}
+ ret = carry_out_calculation(self._name, config=context,
+ callback=self._validator[0],
+ callback_params=validator_params)
+ if ret not in [False, True]:
+ raise ConfigError(_('validator should return a boolean, '
+ 'not {0}').format(ret))
+ return ret
else:
return True
def __init__(self, name, doc, values, default=None, default_multi=None,
requires=None, multi=False, callback=None,
callback_params=None, open_values=False, validator=None,
- validator_args=None, properties=()):
+ validator_params=None, properties=()):
"""
:param values: is a list of values the option can possibly take
"""
requires=requires,
multi=multi,
validator=validator,
- validator_args=validator_args,
+ validator_params=validator_params,
properties=properties)
def impl_get_values(self):
def __init__(self, name, doc, default=None, default_multi=None,
requires=None, multi=False, callback=None,
- callback_params=None, validator=None, validator_args=None,
+ callback_params=None, validator=None, validator_params=None,
properties=None, only_private=False):
self._only_private = only_private
super(IPOption, self).__init__(name, doc, default=default,
requires=requires,
multi=multi,
validator=validator,
- validator_args=validator_args,
+ validator_params=validator_params,
properties=properties)
def _validate(self, value):
def __init__(self, name, doc, default=None, default_multi=None,
requires=None, multi=False, callback=None,
- callback_params=None, validator=None, validator_args=None,
+ callback_params=None, validator=None, validator_params=None,
properties=None, allow_range=False, allow_zero=False,
allow_wellknown=True, allow_registred=True,
allow_private=False):
requires=requires,
multi=multi,
validator=validator,
- validator_args=validator_args,
+ validator_params=validator_params,
properties=properties)
def _validate(self, value):
def __init__(self, name, doc, default=None, default_multi=None,
requires=None, multi=False, callback=None,
- callback_params=None, validator=None, validator_args=None,
+ callback_params=None, validator=None, validator_params=None,
properties=None, allow_ip=False, type_='domainname'):
#netbios: for MS domain
#hostname: to identify the device
requires=requires,
multi=multi,
validator=validator,
- validator_args=validator_args,
+ validator_params=validator_params,
properties=properties)
def _validate(self, value):
require[3], require[4], require[5]))
ret.append(tuple(ret_action))
return frozenset(config_action.keys()), tuple(ret)
+
+
+def validate_callback(callback, callback_params, type_):
+ if type(callback) != FunctionType:
+ raise ValueError(_('{0} should be a function').format(type_))
+ if callback_params is not None:
+ if not isinstance(callback_params, dict):
+ raise ValueError(_('{0}_params should be a dict').format(type_))
+ for key, callbacks in callback_params.items():
+ if key != '' and len(callbacks) != 1:
+ raise ValueError(_('{0}_params with key {1} should not have '
+ 'length different to 1').format(type_,
+ key))
+ if not isinstance(callbacks, tuple):
+ raise ValueError(_('{0}_params should be tuple for key "{1}"'
+ ).format(type_, key))
+ for callbk in callbacks:
+ if isinstance(callbk, tuple):
+ option, force_permissive = callbk
+ if type_ == 'validator' and not force_permissive:
+ raise ValueError(_('validator not support tuple'))
+ if not isinstance(option, Option) and not \
+ isinstance(option, SymLinkOption):
+ raise ValueError(_('{0}_params should have an option '
+ 'not a {0} for first argument'
+ ).format(type_, type(option)))
+ if force_permissive not in [True, False]:
+ raise ValueError(_('{0}_params should have a boolean'
+ 'not a {0} for second argument'
+ ).format(type_, type(force_permissive)))
return True
return False
- def _getcallback_value(self, opt, index=None):
+ def _getcallback_value(self, opt, index=None, max_len=None):
"""
retrieves a value for the options that have a callback
return carry_out_calculation(opt._name, config=self.context(),
callback=callback,
callback_params=callback_params,
- index=index)
+ index=index, max_len=max_len)
def __getitem__(self, opt):
"enables us to use the pythonic dictionary-like access to values"
if opt.impl_has_callback() and (
self._is_default_owner(path) or
(is_frozen and 'force_default_on_freeze' in setting[opt])):
+ lenmaster = None
no_value_slave = False
if (opt.impl_is_multi() and
opt.impl_get_multitype() == multitypes.slave):
if not no_value_slave:
try:
- value = self._getcallback_value(opt)
+ value = self._getcallback_value(opt, max_len=lenmaster)
except ConfigError as config_error:
value = None
# should not raise PropertiesOptionError if option is
def _valid_slave(self, value):
#if slave, had values until master's one
+ values = self.context().cfgimpl_get_values()
masterp = self.context().cfgimpl_get_description().impl_get_path_by_opt(
self.opt.impl_get_master_slaves())
mastervalue = getattr(self.context(), masterp)
masterlen = len(mastervalue)
valuelen = len(value)
if valuelen > masterlen or (valuelen < masterlen and
- not self.context().cfgimpl_get_values(
- )._is_default_owner(self.path)):
+ not values._is_default_owner(self.path)):
raise SlaveError(_("invalid len for the slave: {0}"
" which has {1} as master").format(
self.opt._name, masterp))
elif valuelen < masterlen:
for num in range(0, masterlen - valuelen):
- value.append(self.opt.impl_getdefault_multi())
+ if self.opt.impl_has_callback():
+ # if callback add a value, but this value will not change
+ # anymore automaticly (because this value has owner)
+ index = value.__len__()
+ value.append(values._getcallback_value(self.opt,
+ index=index))
+ else:
+ value.append(self.opt.impl_getdefault_multi())
#else: same len so do nothing
return value
self.opt._name, slave._name))
elif len(value_slave) < masterlen:
for num in range(0, masterlen - len(value_slave)):
- value_slave.append(slave.impl_getdefault_multi(),
- force=True)
+ if slave.impl_has_callback():
+ # if callback add a value, but this value will not
+ # change anymore automaticly (because this value
+ # has owner)
+ index = value_slave.__len__()
+ value_slave.append(
+ values._getcallback_value(slave, index=index),
+ force=True)
+ else:
+ value_slave.append(slave.impl_getdefault_multi(),
+ force=True)
def __setitem__(self, key, value):
self._validate(value)
projects / tiramisu.git / commitdiff