stove/tiramisu
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

ConfigBag optimisation

Browse source
This commit is contained in:
Emmanuel Garette 2018-08-01 08:37:58 +02:00
parent acdddcfe9c
commit 41c17004d2
19 changed files with 1163 additions and 1160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
test/test_cache.py
View file

@ -246,7 +246,7 @@ def test_reset_cache():
api.option('u1').value.get()
assert 'u1' in values._p_.get_cached()
assert 'u1' in settings._p_.get_cached()
c.cfgimpl_reset_cache(None, None, None)
c.cfgimpl_reset_cache(None, None)
assert 'u1' not in values._p_.get_cached()
assert 'u1' not in settings._p_.get_cached()
api.option('u1').value.get()
@ -258,7 +258,7 @@ def test_reset_cache():
assert 'u1' in settings._p_.get_cached()
assert 'u2' in values._p_.get_cached()
assert 'u2' in settings._p_.get_cached()
c.cfgimpl_reset_cache(None, None, None)
c.cfgimpl_reset_cache(None, None)
assert 'u1' not in values._p_.get_cached()
assert 'u1' not in settings._p_.get_cached()
assert 'u2' not in values._p_.get_cached()
@ -273,7 +273,7 @@ def test_reset_cache():
# values = c.cfgimpl_get_values()
# api.option('od1.u1').value.get()
# assert 'od1.u1' in values._p_.get_cached()
# c.od1.cfgimpl_reset_cache(None, None, None)
# c.od1.cfgimpl_reset_cache(None, None)
# assert 'od1.u1' not in values._p_.get_cached()

14
test/test_config_api.py
View file

@ -429,10 +429,10 @@ def test_invalid_option():
raises(ValueError, "DomainnameOption('a', '', multi=True, default_multi=1)")
def test_help():
stro = StrOption('s', '', multi=True)
od1 = OptionDescription('o', '', [stro])
od2 = OptionDescription('o', '', [od1])
cfg = Config(od2)
api = getapi(cfg)
api.help(_display=False, _valid=True)
#def test_help():
# stro = StrOption('s', '', multi=True)
# od1 = OptionDescription('o', '', [stro])
# od2 = OptionDescription('o', '', [od1])
# cfg = Config(od2)
# api = getapi(cfg)
# api.help(_display=False, _valid=True)

20
test/test_masterslaves.py
View file

@ -110,8 +110,8 @@ def test_iter_on_groups():
descr = make_description()
api = getapi(Config(descr))
api.property.read_write()
result = list(api.option('creole').list('optiondescription', group_type=groups.family))
group_names = [res[0] for res in result]
result = api.option('creole').list('optiondescription', group_type=groups.family)
group_names = [res.option.name() for res in result]
assert group_names == ['general', 'interface1']
for i in api.option('creole').list('optiondescription', group_type=groups.family):
#test StopIteration
@ -123,13 +123,15 @@ def test_iter_on_groups_force_permissive():
api = getapi(Config(descr))
api.property.read_write()
api.permissive.set(frozenset(['hidden']))
#result = list(config.creole.general.__iter__(force_permissive=True))
group_names = list(api.forcepermissive.option('creole.general').list())
result = api.forcepermissive.option('creole.general').list()
group_names = [res.option.name() for res in result]
ass = ['numero_etab', 'nom_machine', 'nombre_interfaces',
'activer_proxy_client', 'mode_conteneur_actif',
'mode_conteneur_actif2', 'serveur_ntp', 'time_zone']
assert group_names == ass
group_names = list(api.option('creole.general').list())
# mode_conteneur_actif2 is not visible is not forcepermissive
result = api.option('creole.general').list()
group_names = [res.option.name() for res in result]
ass.remove('mode_conteneur_actif2')
assert group_names == ass
@ -139,8 +141,8 @@ def test_iter_group_on_groups_force_permissive():
api = getapi(Config(descr))
api.property.read_write()
api.permissive.set(frozenset(['hidden']))
result = list(api.forcepermissive.option('creole').list(type='optiondescription', group_type=groups.family))
group_names = [res[0] for res in result]
result = api.forcepermissive.option('creole').list(type='optiondescription', group_type=groups.family)
group_names = [res.option.name() for res in result]
assert group_names == ['general', 'interface1', 'new']
@ -149,8 +151,8 @@ def test_iter_on_groups_props():
api = getapi(Config(descr))
api.property.read_write()
api.option('creole.interface1').property.add('disabled')
result = list(api.option('creole').list(type='optiondescription', group_type=groups.family))
group_names = [res[0] for res in result]
result = api.option('creole').list(type='optiondescription', group_type=groups.family)
group_names = [res.option.name() for res in result]
assert group_names == ['general']

14
test/test_option_callback.py
View file

@ -796,33 +796,32 @@ def test_callback_master_and_slaves_slave_cal():
val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
val2 = StrOption('val2', "", multi=True, callback=return_val)
interface1 = MasterSlaves('val1', '', [val1, val2])
#interface1.impl_set_group_type(groups.master)
maconfig = OptionDescription('rootconfig', '', [interface1, val3])
api = getapi(Config(maconfig))
api.property.read_write()
#
assert api.option('val3').value.get() == []
assert api.option('val1.val1').value.get() == []
#
api.option('val1.val1').value.set(['val1'])
api.option('val3').value.set(['val1'])
assert api.option('val1.val1').value.get() == ['val1']
assert api.option('val1.val2', 0).value.get() == 'val'
#
api.option('val1.val1').value.reset()
api.option('val1.val2', 0).value.set('val')
#
api.option('val3').value.set(['val1', 'val2'])
assert api.option('val1.val2', 0).value.get() == 'val'
assert api.option('val1.val2', 1).value.get() == 'val'
assert api.option('val1.val1').value.get() == ['val1', 'val2']
# len of slave is higher than master's one
api.option('val1.val2', 0).value.set('val1')
api.option('val1.val2', 1).value.set('val2')
api.option('val3').value.set(['val1'])
# cannot remove slave's value because master is calculated
# so raise
if TIRAMISU_VERSION == 2:
raises(SlaveError, "api.option('val1.val1').value.get()")
raises(SlaveError, "api.option('val1.val2', 0).value.get()")
else:
assert api.option('val1.val1').value.get() == ['val1']
raises(SlaveError, "api.option('val1.val2', 0).value.get()")
#
api.option('val3').value.set(['val1', 'val2', 'val3'])
assert api.option('val1.val2', 0).value.get() == 'val1'
assert api.option('val1.val2', 1).value.get() == 'val2'
@ -1020,6 +1019,7 @@ def test_callback_hidden():
api = getapi(Config(maconfig))
api.property.read_write()
raises(PropertiesOptionError, "api.option('od1.opt1').value.get()")
# do not raise, forcepermissive
api.option('od2.opt2').value.get()

12
test/test_slots.py
View file

@ -5,7 +5,7 @@ do_autopath()
from py.test import raises
try:
from tiramisu.setting import ConfigBag
from tiramisu.setting import OptionBag, ConfigBag
tiramisu_version = 3
except:
tiramisu_version = 2
@ -151,10 +151,12 @@ def test_slots_config():
c = Config(od2)
raises(AttributeError, "c.x = 1")
raises(AttributeError, "c.cfgimpl_x = 1")
if tiramisu_version == 2:
sc = c.getattr('a')
else:
sc = c.getattr('a', None, ConfigBag(c))
option_bag = OptionBag()
option_bag.set_option(od2,
'a',
None,
ConfigBag(c))
sc = c.getattr('a', option_bag)
assert isinstance(sc, SubConfig)
raises(AttributeError, "sc.x = 1")
raises(AttributeError, "sc.cfgimpl_x = 1")

442
tiramisu/api.py
View file

@ -22,7 +22,7 @@ from typing import List, Any, Optional, Callable, Union, Dict
from .error import APIError, ConfigError, SlaveError, PropertiesOptionError
from .i18n import _
from .setting import ConfigBag, owners, Undefined, undefined, FORBIDDEN_SET_PROPERTIES
from .setting import ConfigBag, OptionBag, owners, groups, Undefined, undefined, FORBIDDEN_SET_PROPERTIES
from .config import Config, SubConfig, GroupConfig, MetaConfig
from .option import ChoiceOption
@ -102,6 +102,7 @@ class TiramisuHelp:
options.append(self.tmpl_help.format(space, self.icon, root + 'unrestraint', _('access to option without property restriction')))
options.append(self.tmpl_help.format(space, self.icon, root + 'forcepermissive', _('access to option without verifying permissive property')))
root = '[unrestraint.|forcepermissive.]'
if 'registers' in dir(self):
modules = list(self.registers.keys())
modules.sort()
for module_name in modules:
@ -159,20 +160,21 @@ class CommonTiramisu(TiramisuHelp):
registers = {}
def _get_option(self) -> Any:
option = self.config_bag.option
option = self.option_bag.option
if option is None:
option = self.subconfig.cfgimpl_get_description().impl_getchild(self._name,
self.config_bag,
self.subconfig)
self.config_bag.option = option
if self.config_bag.setting_properties:
self.config_bag.config.cfgimpl_get_settings().validate_properties(self._path,
self.option_bag.set_option(option,
self._path,
self.index,
self.config_bag)
if self.config_bag.setting_properties:
self.config_bag.config.cfgimpl_get_settings().validate_properties(self.option_bag)
if self.index is not None:
if option.impl_is_optiondescription() or not option.impl_is_master_slaves('slave'):
raise APIError('index must be set only with a slave option')
self._length = self.subconfig.cfgimpl_get_length_slave(option, self.config_bag)
self._length = self.subconfig.cfgimpl_get_length_slave(self.option_bag)
if self.index >= self._length:
raise SlaveError(_('index "{}" is higher than the master length "{}" '
'for option "{}"').format(self.index,
@ -188,14 +190,16 @@ class CommonTiramisuOption(CommonTiramisu):
slave_need_index = True
def __init__(self,
name: Optional[str],
path: Optional[str]=None,
index: Optional[int]=None,
subconfig: Any=None,
config_bag: Optional[ConfigBag]=None) -> None:
name: str,
path: str,
index: int,
subconfig: Union[Config, SubConfig],
config_bag: ConfigBag,
option_bag: OptionBag) -> None:
self._path = path
self.index = index
self.config_bag = config_bag
self.option_bag = option_bag
self._name = name
self.subconfig = subconfig
if config_bag is not None and self.slave_need_index:
@ -310,7 +314,8 @@ class TiramisuOptionOption(CommonTiramisuOption):
return option.impl_getrequires()
def __getattr__(self, name: str) -> Callable:
if not self._get_option().impl_is_optiondescription() and name != 'get_option':
#if not self._get_option().impl_is_optiondescription() and name != 'get_option':
if not self._get_option().impl_is_optiondescription():
subkey = '_' + name
if subkey in dir(self):
func = getattr(self, subkey)
@ -327,17 +332,19 @@ class TiramisuOptionOwner(CommonTiramisuOption):
"""manager option's owner"""
def __init__(self,
name: Optional[str],
path: Optional[str]=None,
index: Optional[int]=None,
subconfig: Union[None, Config, SubConfig]=None,
config_bag: Optional[ConfigBag]=None) -> None:
name: str,
path: str,
index: int,
subconfig: Union[Config, SubConfig],
config_bag: ConfigBag,
option_bag: OptionBag) -> None:
super().__init__(name,
path,
index,
subconfig,
config_bag)
config_bag,
option_bag)
if config_bag:
self.values = self.config_bag.config.cfgimpl_get_values()
@ -345,17 +352,13 @@ class TiramisuOptionOwner(CommonTiramisuOption):
def get(self):
"""get owner for a specified option"""
option = self._get_option()
return self.values.getowner(self._path,
self.index,
self.config_bag)
return self.values.getowner(self.option_bag)
@count
def isdefault(self):
"""is option has defaut value"""
self._get_option()
return self.values.is_default_owner(self._path,
self.index,
self.config_bag)
return self.values.is_default_owner(self.option_bag)
@count
def set(self, owner):
@ -369,10 +372,8 @@ class TiramisuOptionOwner(CommonTiramisuOption):
except AttributeError:
owners.addowner(owner)
obj_owner = getattr(owners, owner)
self.values.setowner(self._path,
self.index,
obj_owner,
self.config_bag)
self.values.setowner(obj_owner,
self.option_bag)
class TiramisuOptionProperty(CommonTiramisuOption):
@ -381,16 +382,18 @@ class TiramisuOptionProperty(CommonTiramisuOption):
slave_need_index = False
def __init__(self,
name: Optional[str],
path: Optional[str]=None,
index: Optional[int]=None,
subconfig: Union[None, Config, SubConfig]=None,
config_bag: Optional[ConfigBag]=None) -> None:
name: str,
path: str,
index: int,
subconfig: Union[Config, SubConfig],
config_bag: ConfigBag,
option_bag: OptionBag) -> None:
super().__init__(name,
path,
index,
subconfig,
config_bag)
config_bag,
option_bag)
if config_bag:
self.settings = config_bag.config.cfgimpl_get_settings()
@ -400,12 +403,9 @@ class TiramisuOptionProperty(CommonTiramisuOption):
self._get_option()
if apply_requires:
self._test_slave_index()
properties = self.settings.getproperties(self._path,
self.index,
self.config_bag,
apply_requires)
if TIRAMISU_VERSION == 2:
properties = properties.get()
else:
self.option_bag.apply_requires = False
properties = self.option_bag.properties
return set(properties)
@count
@ -415,33 +415,27 @@ class TiramisuOptionProperty(CommonTiramisuOption):
if prop in FORBIDDEN_SET_PROPERTIES:
raise ConfigError(_('cannot add this property: "{0}"').format(
' '.join(prop)))
props = self.settings.getproperties(self._path,
None,
self.config_bag,
props = self.settings.getproperties(self.option_bag,
apply_requires=False)
self.settings.setproperties(self._path,
props | {prop},
self.config_bag)
self.option_bag)
@count
def pop(self, prop):
"""remove new property for an option"""
self._get_option()
props = self.settings.getproperties(self._path,
self.index,
self.config_bag,
props = self.settings.getproperties(self.option_bag,
apply_requires=False)
self.settings.setproperties(self._path,
props - {prop},
self.config_bag)
self.option_bag)
@count
def reset(self):
"""reset all personalised properties"""
self._get_option()
self.settings.reset(self.config_bag.option,
self._path,
self.config_bag)
self.settings.reset(self.option_bag)
class TiramisuOptionPermissive(CommonTiramisuOption):
@ -450,16 +444,18 @@ class TiramisuOptionPermissive(CommonTiramisuOption):
slave_need_index = False
def __init__(self,
name: Optional[str],
path: Optional[str]=None,
index: Optional[int]=None,
subconfig: Union[None, Config, SubConfig]=None,
config_bag: Optional[ConfigBag]=None) -> None:
name: str,
path: str,
index: int,
subconfig: Union[Config, SubConfig],
config_bag: ConfigBag,
option_bag: OptionBag) -> None:
super().__init__(name,
path,
index,
subconfig,
config_bag)
config_bag,
option_bag)
if config_bag:
self.settings = config_bag.config.cfgimpl_get_settings()
@ -475,20 +471,8 @@ class TiramisuOptionPermissive(CommonTiramisuOption):
@count
def set(self, permissives):
"""set permissives value"""
if TIRAMISU_VERSION == 2:
permissives = tuple(permissives)
path = self._path
opt = self._opt
self.settings.setpermissive(opt=opt,
path=path,
config_bag=self.config_bag,
permissive=permissives)
else:
path = self._path
opt = self._get_option()
self.settings.setpermissive(opt=opt,
path=path,
config_bag=self.config_bag,
self._get_option()
self.settings.setpermissive(self.option_bag,
permissives=permissives)
@count
@ -526,12 +510,10 @@ class TiramisuOptionValue(CommonTiramisuOption):
@count
def get(self):
"""get option's value"""
self._get_option()
self._test_slave_index()
settings = self.config_bag.config.cfgimpl_get_settings()
value = self.subconfig.getattr(self._name,
self.index,
self.config_bag)
self.option_bag)
#if isinstance(value, Multi):
# value = list(value)
return value
@ -545,35 +527,35 @@ class TiramisuOptionValue(CommonTiramisuOption):
if isinstance(value, list):
while undefined in value:
idx = value.index(undefined)
value[idx] = values.getdefaultvalue(self._path,
option_bag = OptionBag()
option_bag.set_option(self.option_bag.option,
self.option_bag.path,
idx,
self.config_bag)
value[idx] = values.getdefaultvalue(option_bag)
else:
if value == undefined:
value = values.getdefaultvalue(self._path,
self.index,
self.config_bag)
self.subconfig.setattr(self._name,
self.index,
value,
self.config_bag)
value = values.getdefaultvalue(self.option_bag)
self.subconfig.setattr(value,
self.option_bag)
@count
def _pop(self, index):
"""pop value for a master option (only for master option)"""
self._get_option()
self.config_bag.config.delattr(self._path,
index,
self.config_bag)
if self.option_bag.option.impl_is_symlinkoption():
raise TypeError(_("can't delete a SymLinkOption"))
self.config_bag.config.cfgimpl_get_values().reset_master(index,
self.option_bag,
self.subconfig)
@count
def reset(self):
"""reset value for a value"""
self._get_option()
self._test_slave_index()
self.config_bag.config.delattr(self._path,
self.index,
self.config_bag)
#self.config_bag.config.delattr(self.option_bag)
self.subconfig.delattr(self.option_bag)
@count
def _len_master(self):
@ -590,7 +572,7 @@ class TiramisuOptionValue(CommonTiramisuOption):
option = self._get_option()
# for example if index is None
if '_length' not in vars(self):
self._length = self.subconfig.cfgimpl_get_length_slave(option, self.config_bag)
self._length = self.subconfig.cfgimpl_get_length_slave(self.option_bag)
return self._length
def __getattr__(self, name: str) -> Callable:
@ -608,7 +590,8 @@ class TiramisuOptionValue(CommonTiramisuOption):
@count
def _list(self):
"""all values available for an option (only for choiceoption)"""
return self.config_bag.option.impl_get_values(self.config_bag)
self._get_option()
return self._get_option().impl_get_values(self.option_bag)
def registers(registers: Dict[str, type], prefix: str) -> None:
@ -620,18 +603,26 @@ def registers(registers: Dict[str, type], prefix: str) -> None:
class TiramisuOption(CommonTiramisu):
registers = {}
def __init__(self,
name: Optional[str],
path: Optional[str]=None,
index: Optional[int]=None,
subconfig: Union[None, Config, SubConfig]=None,
config_bag: Optional[ConfigBag]=None) -> None:
config_bag: Optional[ConfigBag]=None,
option_bag: Optional[OptionBag]=None) -> None:
self._name = name
self.subconfig = subconfig
if subconfig == None:
raise Exception()
self._path = path
self.index = index
self.config_bag = config_bag
self.registers = {}
if option_bag:
self.option_bag = option_bag
else:
self.option_bag = OptionBag()
if not self.registers:
registers(self.registers, self.__class__.__name__)
def __getattr__(self, subfunc: str) -> Any:
@ -640,11 +631,14 @@ class TiramisuOption(CommonTiramisu):
self._path,
self.index,
self.subconfig,
self.config_bag)
self.config_bag,
self.option_bag)
elif subfunc == 'make_dict' and self._get_option().impl_is_optiondescription():
return self._make_dict
elif subfunc == 'find' and self._get_option().impl_is_optiondescription():
return self._find
elif subfunc == 'get' and self._get_option().impl_is_optiondescription():
return self._get
elif subfunc == 'list' and self._get_option().impl_is_optiondescription():
return self._list
elif subfunc == 'group_type' and self._get_option().impl_is_optiondescription():
@ -659,9 +653,9 @@ class TiramisuOption(CommonTiramisu):
withoption=None,
fullpath=False):
"""return dict with path as key and value for an optiondescription (only for optiondescription)"""
self._get_option()
return self.config_bag.config.getattr(self._path,
None,
self.config_bag).make_dict(config_bag=self.config_bag,
self.option_bag).make_dict(config_bag=self.config_bag,
flatten=flatten,
fullpath=fullpath,
withoption=withoption,
@ -680,19 +674,42 @@ class TiramisuOption(CommonTiramisu):
bytype=type,
_subpath=self._path,
config_bag=self.config_bag):
config_bag = self.config_bag.copy('nooption')
subconfig, name = config_bag.config.cfgimpl_get_home_by_path(path,
config_bag)
subconfig, name = self.config_bag.config.cfgimpl_get_home_by_path(path,
self.config_bag)
t_option = TiramisuOption(name,
path,
None, # index for a slave ?
subconfig,
config_bag)
self.config_bag)
if first:
return t_option
ret.append(t_option)
return ret
@count
def _get(self, name):
self._get_option()
current_option = self.option_bag.option.impl_getchild(name,
self.config_bag,
self.subconfig)
path = self.option_bag.path + '.' + name
option_bag= OptionBag()
option_bag.set_option(current_option,
path,
None,
self.config_bag)
if current_option.impl_is_optiondescription():
subconfig = self.subconfig.getattr(name,
option_bag)
else:
subconfig = self.subconfig
return TiramisuOption(name,
path,
None,
subconfig,
self.config_bag,
option_bag)
@count
def _group_type(self):
"""get type for an optiondescription (only for optiondescription)"""
@ -703,26 +720,57 @@ class TiramisuOption(CommonTiramisu):
type='all',
group_type=None):
"""list options in an optiondescription (only for optiondescription)"""
if type == 'optiondescription':
return self.config_bag.config.getattr(self._path,
None,
self.config_bag
).iter_groups(self.config_bag, group_type)
elif type == 'all':
return self.config_bag.config.getattr(self._path,
None,
self.config_bag
).cfgimpl_get_children(self.config_bag)
else:
if type not in ('all', 'optiondescription'):
raise APIError(_('unknown list type {}').format(type))
if group_type is not None and not isinstance(group_type,
groups.GroupType):
raise TypeError(_("unknown group_type: {0}").format(group_type))
def _filter(opt):
if not self.config_bag.force_unrestraint:
name = opt.impl_getname()
path = subconfig._get_subpath(name)
option_bag = OptionBag()
option_bag.set_option(opt,
path,
None,
self.config_bag)
self.subconfig.getattr(name,
option_bag)
option = self._get_option()
name = option.impl_getname()
path = self.subconfig._get_subpath(name)
option_bag = OptionBag()
option_bag.set_option(option,
path,
None,
self.config_bag)
subconfig = self.subconfig.getattr(name,
option_bag)
for opt in option.impl_getchildren(self.config_bag):
try:
subsubconfig = _filter(opt)
except PropertiesOptionError:
continue
if opt.impl_is_optiondescription():
if type == 'optiondescription' and \
(group_type and opt.impl_get_group_type() != group_type):
continue
else:
if type == 'optiondescription':
continue
name = opt.impl_getname()
yield TiramisuOption(name,
subconfig._get_subpath(name),
None,
subconfig,
self.config_bag)
class TiramisuContext(TiramisuHelp):
def __init__(self,
config_bag: Optional[ConfigBag]) -> None:
self.config_bag = config_bag
self.registers = {}
registers(self.registers, self.__class__.__name__)
class TiramisuContextInformation(TiramisuContext):
@ -778,7 +826,8 @@ class TiramisuContextValue(TiramisuContext):
def reset(self,
path):
"""reset value for a GroupConfig or a MetaConfig"""
self.config_bag.config.reset(path, self.config_bag)
self.config_bag.config.reset(path,
self.config_bag)
@count
def exportation(self):
@ -789,7 +838,7 @@ class TiramisuContextValue(TiramisuContext):
def importation(self, values):
"""import values"""
self.config_bag.config.cfgimpl_get_values()._p_.importation(values)
self.config_bag.config.cfgimpl_reset_cache(None, None, None)
self.config_bag.config.cfgimpl_reset_cache(None, None)
class TiramisuContextOwner(TiramisuContext):
@ -819,7 +868,10 @@ class TiramisuContextProperty(TiramisuContext):
"""set configuration to read only mode"""
settings = self.config_bag.config.cfgimpl_get_settings()
settings.read_only()
self.config_bag.delete('setting_properties')
try:
del self.config_bag.setting_properties
except AttributeError:
pass
@count
def read_write(self):
@ -828,7 +880,10 @@ class TiramisuContextProperty(TiramisuContext):
settings.read_write()
# #FIXME ?
settings.set_context_permissive(frozenset(['hidden']))
self.config_bag.delete('setting_properties')
try:
del self.config_bag.setting_properties
except AttributeError:
pass
#/FIXME ?
@count
@ -859,9 +914,7 @@ class TiramisuContextProperty(TiramisuContext):
@count
def reset(self):
"""remove configuration properties"""
self.config_bag.config.cfgimpl_get_settings().reset(None,
None,
None)
self.config_bag.config.cfgimpl_get_settings().reset(None)
@count
def exportation(self):
@ -872,7 +925,8 @@ class TiramisuContextProperty(TiramisuContext):
def importation(self, properties):
"""import configuration properties"""
self.config_bag.config.cfgimpl_get_settings()._p_.importation(properties)
self.config_bag.config.cfgimpl_reset_cache(None, None, None)
self.config_bag.config.cfgimpl_reset_cache(None,
None)
class TiramisuContextPermissive(TiramisuContext):
@ -897,7 +951,8 @@ class TiramisuContextPermissive(TiramisuContext):
def importation(self, permissives):
"""import configuration permissives"""
self.config_bag.config.cfgimpl_get_settings()._pp_.importation(permissives)
self.config_bag.config.cfgimpl_reset_cache(None, None, None)
self.config_bag.config.cfgimpl_reset_cache(None,
None)
@ -918,28 +973,28 @@ class TiramisuContextOption(TiramisuContext):
bytype=type,
#_subpath=self._path,
config_bag=self.config_bag):
config_bag = self.config_bag.copy('nooption')
subconfig, name = config_bag.config.cfgimpl_get_home_by_path(path,
config_bag)
subconfig, name = self.config_bag.config.cfgimpl_get_home_by_path(path,
self.config_bag)
t_option = TiramisuOption(name,
path,
None, # index for a slave ?
subconfig,
config_bag)
self.config_bag)
if first:
return t_option
ret.append(t_option)
return ret
#@count
#def get(self, path):
# """"""
# config_bag = self.config_bag.copy()
# config_bag.validate = False
# config_bag.force_unrestraint = True
# config_bag.setting_properties = None
# return self.config_bag.config.unwrap_from_path(path,
# config_bag)
@count
def get(self, name):
option = self.config_bag.config.cfgimpl_get_description().impl_getchild(name,
self.config_bag,
self.config_bag.config)
return TiramisuOption(name,
name,
None,
self.config_bag.config,
self.config_bag)
@count
def make_dict(self,
@ -960,10 +1015,23 @@ class TiramisuContextOption(TiramisuContext):
group_type=None,
recursive=False):
"""list content of an optiondescription"""
# FIXME should return TiramisuOption !!!
if group_type is not None and not isinstance(group_type,
groups.GroupType):
raise TypeError(_("unknown group_type: {0}").format(group_type))
if type == 'optiondescription':
if recursive:
raise APIError(_('not implemented yet'))
else:
if not self.config_bag.force_unrestraint:
option = self.config_bag.config.cfgimpl_get_description()
for opt in option.impl_getchildren(self.config_bag):
if type == 'optiondescription' and not opt.impl_is_optiondescription():
continue
yield opt.impl_getname()
else:
# FIXME itergroups !!!
return self.config_bag.config.iter_groups(self.config_bag, group_type)
elif type == 'all':
if group_type:
@ -998,70 +1066,82 @@ class TiramisuDispatcher:
pass
class TiramisuDispatcherConfig(TiramisuDispatcher, TiramisuContextConfig):
def __call__(self, path: Optional[str]):
"""select a child Tiramisu configuration (only with MetaConfig or GroupConfig)"""
config = self.config_bag.config
if path is None:
return TiramisuAPI(config,
force_permissive=self.config_bag.force_permissive,
force_unrestraint=self.config_bag.force_unrestraint)
spaths = path.split('.')
for spath in spaths:
config = config.getconfig(spath)
return TiramisuAPI(config,
force_permissive=self.config_bag.force_permissive,
force_unrestraint=self.config_bag.force_unrestraint)
class TiramisuDispatcherOption(TiramisuDispatcher, TiramisuContextOption):
subhelp = TiramisuOption
def __call__(self, path: str, index: Optional[int]=None) -> TiramisuOption:
"""select a option (index only for slave option)"""
config_bag = self.config_bag.copy()
validate = not config_bag.force_unrestraint
if not validate:
config_bag.setting_properties = None
subconfig, name = config_bag.config.cfgimpl_get_home_by_path(path,
config_bag)
return TiramisuOption(name,
path,
index,
subconfig,
config_bag)
class TiramisuAPI(TiramisuHelp):
registers = {}
def __init__(self,
config: Union[Config, GroupConfig, MetaConfig],
force_permissive: bool=False,
force_unrestraint: bool=False) -> None:
config: Union[Config, GroupConfig, MetaConfig, ConfigBag]) -> None:
self._config = config
self.force_permissive = force_permissive
self.force_unrestraint = force_unrestraint
self.registers = {}
if not self.registers:
registers(self.registers, 'TiramisuContext')
registers(self.registers, 'TiramisuDispatcher')
def __getattr__(self, subfunc: str) -> Any:
if subfunc == 'forcepermissive':
return TiramisuAPI(config=self._config,
force_permissive=True,
force_unrestraint=self.force_unrestraint)
if isinstance(self._config, ConfigBag):
config = self._config.config
force = self._config.force_unrestraint
else:
config = self._config
force = None
config_bag = ConfigBag(config=config,
force_permissive=True)
if force is not None:
config_bag.force_unrestraint = force
return TiramisuAPI(config_bag)
elif subfunc == 'unrestraint':
return TiramisuAPI(config=self._config,
force_permissive=self.force_permissive,
if isinstance(self._config, ConfigBag):
config = self._config.config
force = self._config.force_permissive
else:
config = self._config
force = None
config_bag = ConfigBag(config=config,
force_unrestraint=True)
if force is not None:
config_bag.force_permissive = force
return TiramisuAPI(config_bag)
elif subfunc in self.registers:
config_bag = ConfigBag(config=self._config,
force_permissive=self.force_permissive,
force_unrestraint=self.force_unrestraint)
if not isinstance(self._config, ConfigBag):
config_bag = ConfigBag(config=self._config)
else:
config_bag = self._config
return self.registers[subfunc](config_bag)
else:
raise APIError(_('please specify a valid sub function ({})').format(subfunc))
class TiramisuDispatcherConfig(TiramisuDispatcher, TiramisuContextConfig):
def __call__(self,
path: Optional[str]) -> TiramisuAPI:
"""select a child Tiramisu configuration (only with MetaConfig or GroupConfig)"""
if path is None:
return TiramisuAPI(self.config_bag)
spaths = path.split('.')
config = self.config_bag.config
for spath in spaths:
config = config.getconfig(spath)
config_bag = ConfigBag(config=config,
force_unrestraint=self.config_bag.force_unrestraint,
force_permissive=self.config_bag.force_permissive)
return TiramisuAPI(config_bag)
class TiramisuDispatcherOption(TiramisuDispatcher, TiramisuContextOption):
subhelp = TiramisuOption
def __call__(self,
path: str,
index: Optional[int]=None) -> TiramisuOption:
"""select a option (index only for slave option)"""
subconfig, name = self.config_bag.config.cfgimpl_get_home_by_path(path,
self.config_bag)
return TiramisuOption(name,
path,
index,
subconfig,
self.config_bag)
@count
def getapi(config: Union[Config, GroupConfig, MetaConfig]):
"""instanciate TiramisuAPI

36
tiramisu/autolib.py
View file

@ -23,7 +23,7 @@ from typing import Any, Optional, Union, Callable, Dict, List
from .error import PropertiesOptionError, ConfigError, SlaveError
from .i18n import _
from .setting import undefined, ConfigBag, Undefined
from .setting import undefined, ConfigBag, OptionBag, Undefined
from .option.symlinkoption import DynSymLinkOption
from .storage import get_default_values_storages, get_default_settings_storages
from .function import ParamValue, ParamContext, ParamIndex, ParamOption, Params
@ -34,7 +34,7 @@ def manager_callback(callbk: Union[ParamOption, ParamValue],
option,
index: Optional[int],
orig_value,
config_bag: ConfigBag,
option_bag: OptionBag,
context) -> Any:
"""replace Param by true value"""
if isinstance(callbk, ParamValue):
@ -55,10 +55,6 @@ def manager_callback(callbk: Union[ParamOption, ParamValue],
path = opt.impl_getpath(context)
else:
path = context.cfgimpl_get_description().impl_get_path_by_opt(opt)
# don't validate if option is option that we tried to validate
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = opt
sconfig_bag.force_permissive = True
if index is not None and opt.impl_is_master_slaves() and \
opt.impl_get_master_slaves().in_same_group(option):
if opt == option:
@ -76,15 +72,25 @@ def manager_callback(callbk: Union[ParamOption, ParamValue],
if opt == option and orig_value is not undefined and \
(not opt.impl_is_master_slaves('slave') or index is None):
return orig_value
# don't validate if option is option that we tried to validate
config_bag = ConfigBag(config=option_bag.config_bag.config,
_setting_properties=option_bag.config_bag._setting_properties,
force_permissive=True,
force_unrestraint=option_bag.config_bag.force_unrestraint,
_validate=option_bag.config_bag._validate)
soption_bag = OptionBag()
soption_bag.set_option(opt,
path,
index_,
config_bag)
soption_bag.fromconsistency = option_bag.fromconsistency.copy()
if opt == option:
sconfig_bag.setting_properties = None
sconfig_bag.force_unrestraint= False
sconfig_bag.validate = False
soption_bag.config_bag.force_unrestraint = True
soption_bag.config_bag.validate = False
try:
# get value
value = context.getattr(path,
index_,
sconfig_bag)
soption_bag)
if with_index:
return value[index]
return value
@ -100,7 +106,7 @@ def carry_out_calculation(option,
callback: Callable,
callback_params: Optional[Params],
index: Optional[int],
config_bag: Optional[ConfigBag],
option_bag: Optional[OptionBag],
orig_value=undefined,
is_validator: int=False):
@ -217,7 +223,7 @@ def carry_out_calculation(option,
kwargs = {}
# if callback_params has a callback, launch several time calculate()
if option.issubdyn():
#FIXME why here? should be ParamSuffix !
#FIXME why here? should be a ParamSuffix !
kwargs['suffix'] = option.impl_getsuffix()
if callback_params:
for callbk in callback_params.args:
@ -226,7 +232,7 @@ def carry_out_calculation(option,
option,
index,
orig_value,
config_bag,
option_bag,
context)
if value is undefined:
return undefined
@ -239,7 +245,7 @@ def carry_out_calculation(option,
option,
index,
orig_value,
config_bag,
option_bag,
context)
if value is undefined:
return undefined

503
tiramisu/config.py
View file

@ -20,7 +20,6 @@
# ____________________________________________________________
"options handler global entry point"
import weakref
from time import time
from copy import copy
@ -29,7 +28,7 @@ from .option.syndynoptiondescription import SynDynOptionDescription
from .option.dynoptiondescription import DynOptionDescription
from .option.masterslave import MasterSlaves
from .option.baseoption import BaseOption, valid_name
from .setting import ConfigBag, groups, Settings, undefined
from .setting import OptionBag, ConfigBag, groups, Settings, undefined
from .storage import get_storages, get_default_values_storages
from .value import Values # , Multi
from .i18n import _
@ -50,7 +49,8 @@ class SubConfig(object):
descr,
context,
config_bag,
subpath=None):
subpath=None,
fromconsistency=None):
""" Configuration option management master class
:param descr: describes the configuration schema
@ -73,23 +73,38 @@ class SubConfig(object):
descr.impl_get_group_type() == groups.master:
master = descr.getmaster()
masterpath = master.impl_getname()
mconfig_bag = config_bag.copy('nooption')
mconfig_bag.option = master
mconfig_bag.validate = False
value = self.getattr(masterpath,
full_masterpath = self._get_subpath(masterpath)
cconfig_bag = ConfigBag(config=config_bag.config,
_setting_properties=config_bag._setting_properties,
force_permissive=config_bag.force_permissive,
force_unrestraint=config_bag.force_unrestraint,
_validate=False)
moption_bag = OptionBag()
moption_bag.set_option(master,
full_masterpath,
None,
mconfig_bag)
cconfig_bag)
if fromconsistency:
moption_bag.fromconsistency = fromconsistency
value = self.getattr(masterpath,
moption_bag)
self._impl_length = len(value)
def cfgimpl_get_length(self):
return self._impl_length
def cfgimpl_get_length_slave(self, option, config_bag):
if option.impl_is_symlinkoption():
def cfgimpl_get_length_slave(self,
option_bag):
if option_bag.option.impl_is_symlinkoption():
context = self.cfgimpl_get_context()
sconfig_bag = config_bag.copy('nooption')
subconfig, _ = context.cfgimpl_get_home_by_path(option.impl_getopt().impl_getpath(context),
sconfig_bag)
#soption_bag = OptionBag()
#soption_bag.set_option(option_bag.option.impl_getopt(),
# option_bag.option.impl_getopt().impl_getpath(context),
# None,
# option_bag.config_bag)
path = option_bag.option.impl_getopt().impl_getpath(context)
subconfig, _ = context.cfgimpl_get_home_by_path(path,
option_bag.config_bag)
return subconfig.cfgimpl_get_length()
else:
return self.cfgimpl_get_length()
@ -99,54 +114,65 @@ class SubConfig(object):
values,
settings,
resetted_opts,
config_bag,
opt,
path):
option_bag):
if path in resetted_opts:
if option_bag.path in resetted_opts:
return
resetted_opts.append(path)
for woption in opt._get_dependencies(self):
resetted_opts.append(option_bag.path)
for woption in option_bag.option._get_dependencies(self):
option = woption()
if option.impl_is_dynoptiondescription():
for doption in option.get_syndynoptiondescriptions(config_bag):
for doption in option.get_syndynoptiondescriptions(option_bag):
doption_path = doption.impl_getpath(self)
doption_bag = OptionBag()
doption_bag.set_option(doption,
doption_path,
option_bag.index,
option_bag.config_bag)
self.reset_one_option_cache(desc,
values,
settings,
resetted_opts,
config_bag,
doption,
doption_path)
doption_bag)
elif option.issubdyn():
for doption in desc.build_dynoptions(option, config_bag):
doption_bag = OptionBag()
doption_path = option.impl_getpath(self)
doption_bag.set_option(option,
doption_path,
option_bag.index,
option_bag.config_bag)
for doption in desc.build_dynoptions(doption_bag):
doption_path = doption.impl_getpath(self)
doption_bag = OptionBag()
doption_bag.set_option(doption,
doption_path,
option_bag.index,
option_bag.config_bag)
self.reset_one_option_cache(desc,
values,
settings,
resetted_opts,
config_bag,
doption,
doption_path)
doption_bag)
else:
option_path = option.impl_getpath(self)
doption_bag = OptionBag()
doption_bag.set_option(option,
option_path,
option_bag.index,
option_bag.config_bag)
self.reset_one_option_cache(desc,
values,
settings,
resetted_opts,
config_bag,
option,
option_path)
doption_bag)
del option
opt.reset_cache(path,
option_bag.option.reset_cache(option_bag.path,
values,
settings,
resetted_opts)
def cfgimpl_reset_cache(self,
opt,
path,
config_bag,
option_bag,
resetted_opts=None):
"""reset all settings in cache
"""
@ -158,79 +184,40 @@ class SubConfig(object):
values = context.cfgimpl_get_values()
settings = context.cfgimpl_get_settings()
if not None in (opt, path):
if option_bag is not None:
self.reset_one_option_cache(desc,
values,
settings,
resetted_opts,
config_bag,
opt,
path)
option_bag)
else:
values._p_.reset_all_cache()
settings._p_.reset_all_cache()
def cfgimpl_get_home_by_path(self,
path,
config_bag):
config_bag,
fromconsistency=None):
""":returns: tuple (config, name)"""
path = path.split('.')
for step in path[:-1]:
sconfig_bag = config_bag.copy('nooption')
self = self.getattr(step,
option_bag = OptionBag()
option = self.cfgimpl_get_description().impl_getchild(step,
config_bag,
self)
subpath = self._get_subpath(step)
option_bag.set_option(option,
subpath,
None,
sconfig_bag)
config_bag)
if fromconsistency is not None:
option_bag.fromconsistency = fromconsistency
self = self.getattr(step,
option_bag)
if not isinstance(self, SubConfig):
raise AttributeError(_('unknown option {}').format(path[-1]))
return self, path[-1]
# ______________________________________________________________________
def iter_groups(self,
config_bag,
group_type=None):
"""iteration on groups objects only.
All groups are returned if `group_type` is `None`, otherwise the groups
can be filtered by categories (families, or whatever).
:param group_type: if defined, is an instance of `groups.GroupType`
or `groups.MasterGroupType` that lives in
`setting.groups`
"""
if group_type is not None and not isinstance(group_type,
groups.GroupType):
raise TypeError(_("unknown group_type: {0}").format(group_type))
for child in self.cfgimpl_get_description().impl_getchildren(config_bag):
if child.impl_is_optiondescription():
nconfig_bag = config_bag.copy('nooption')
nconfig_bag.option = child
try:
if group_type is None or (group_type is not None and
child.impl_get_group_type()
== group_type):
name = child.impl_getname()
yield name, self.getattr(name,
None,
nconfig_bag)
except PropertiesOptionError:
pass
def cfgimpl_get_children(self,
config_bag):
context = self.cfgimpl_get_context()
for opt in self.cfgimpl_get_description().impl_getchildren(config_bag):
nconfig_bag = config_bag.copy('nooption')
nconfig_bag.option = opt
name = opt.impl_getname()
if nconfig_bag.setting_properties is not None:
subpath = self._get_subpath(name)
try:
context.cfgimpl_get_settings().validate_properties(subpath,
None,
nconfig_bag)
except PropertiesOptionError:
continue
yield name
# ______________________________________________________________________
def cfgimpl_get_context(self):
"""context could be None, we need to test it
@ -245,7 +232,7 @@ class SubConfig(object):
def cfgimpl_get_description(self):
if self._impl_descr is None:
raise ConfigError(_('no option description found for this config'
raise ConfigError(_('there is no option description for this config'
' (may be GroupConfig)'))
else:
return self._impl_descr
@ -257,63 +244,39 @@ class SubConfig(object):
return self.cfgimpl_get_context()._impl_values
def setattr(self,
name,
index,
value,
config_bag,
option_bag,
_commit=True):
context = self.cfgimpl_get_context()
if '.' in name:
# when set_value
self, name = self.cfgimpl_get_home_by_path(name,
config_bag)
if config_bag.option is None:
config_bag.option = self.cfgimpl_get_description().impl_getchild(name,
config_bag,
self)
if config_bag.option.impl_is_symlinkoption():
#self, name = self.cfgimpl_get_home_by_path(option_bag.path,
# option_bag.config_bag)
#if config_bag.option is None:
# config_bag.option = self.cfgimpl_get_description().impl_getchild(name,
# config_bag,
# self)
if option_bag.option.impl_is_symlinkoption():
raise ConfigError(_("can't assign to a SymLinkOption"))
else:
path = self._get_subpath(name)
if config_bag.setting_properties:
context.cfgimpl_get_settings().validate_properties(path,
index,
config_bag)
self.cfgimpl_get_description().impl_validate_value(config_bag.option,
context = self.cfgimpl_get_context()
if option_bag.config_bag.setting_properties:
context.cfgimpl_get_settings().validate_properties(option_bag)
self.cfgimpl_get_description().impl_validate_value(option_bag.option,
value,
self)
return context.cfgimpl_get_values().setvalue(path,
index,
value,
config_bag,
return context.cfgimpl_get_values().setvalue(value,
option_bag,
_commit)
def delattr(self,
name,
index,
config_bag):
if '.' in name:
self, name = self.cfgimpl_get_home_by_path(name,
config_bag)
option = config_bag.option
option_bag):
option = option_bag.option
if option.impl_is_symlinkoption():
raise TypeError(_("can't delete a SymLinkOption"))
subpath = self._get_subpath(name)
values = self.cfgimpl_get_values()
if index is not None:
if option.impl_is_master_slaves('master'):
values.reset_master(self,
subpath,
index,
config_bag)
elif option.impl_is_master_slaves('slave'):
values.reset_slave(subpath,
index,
config_bag)
if option_bag.index is not None:
values.reset_slave(option_bag)
else:
values.reset(subpath,
config_bag)
values.reset(option_bag)
def _get_subpath(self, name):
if self._impl_path is None:
@ -324,71 +287,73 @@ class SubConfig(object):
def getattr(self,
name,
index,
config_bag):
option_bag):
"""
attribute notation mechanism for accessing the value of an option
:param name: attribute name
:return: option's value if name is an option name, OptionDescription
otherwise
"""
config_bag = option_bag.config_bag
if '.' in name:
if option_bag.fromconsistency:
fromconsistency = option_bag.fromconsistency.copy()
else:
fromconsistency = None
self, name = self.cfgimpl_get_home_by_path(name,
config_bag)
context = self.cfgimpl_get_context()
option = config_bag.option
if option is None:
option = self.cfgimpl_get_description().impl_getchild(name,
config_bag,
self)
config_bag.option = option
if option.impl_is_symlinkoption():
opt = option.impl_getopt()
path = context.cfgimpl_get_description().impl_get_path_by_opt(opt)
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.ori_option = option
sconfig_bag.option = opt
return context.getattr(path,
index,
sconfig_bag)
fromconsistency)
subpath = self._get_subpath(name)
if config_bag.setting_properties:
self.cfgimpl_get_settings().validate_properties(subpath,
index,
option = option_bag.option
if option.impl_is_symlinkoption():
soption_bag = OptionBag()
soption_bag.set_option(option.impl_getopt(),
None,
option_bag.index,
config_bag)
soption_bag.ori_option = option
context = self.cfgimpl_get_context()
return context.getattr(soption_bag.path,
soption_bag)
if config_bag.setting_properties:
self.cfgimpl_get_settings().validate_properties(option_bag)
if option.impl_is_optiondescription():
if option_bag.fromconsistency:
fromconsistency = option_bag.fromconsistency.copy()
else:
fromconsistency = None
return SubConfig(option,
self._impl_context,
config_bag,
subpath)
option_bag.path,
fromconsistency)
if option.impl_is_master_slaves('slave'):
length = self.cfgimpl_get_length_slave(option, config_bag)
slave_len = self.cfgimpl_get_values()._p_.get_max_length(subpath)
length = self.cfgimpl_get_length_slave(option_bag)
slave_len = self.cfgimpl_get_values()._p_.get_max_length(option_bag.path)
if slave_len > length:
raise SlaveError(_('slave option "{}" has higher length "{}" than the master '
'length "{}"').format(option.impl_get_display_name(),
slave_len,
length,
subpath))
if option.impl_is_master_slaves('slave') and index is None:
option_bag.index))
if option.impl_is_master_slaves('slave') and option_bag.index is None:
value = []
for idx in range(length):
config_bag.properties = None
value.append(self.getattr(name,
soption_bag = OptionBag()
soption_bag.set_option(option,
option_bag.path,
idx,
config_bag))
config_bag)
soption_bag.fromconsistency = option_bag.fromconsistency.copy()
value.append(self.getattr(name,
soption_bag))
else:
value = self.cfgimpl_get_values().get_cached_value(subpath,
index,
config_bag)
value = self.cfgimpl_get_values().get_cached_value(option_bag)
if config_bag.validate_properties:
self.cfgimpl_get_settings().validate_mandatory(subpath,
index,
value,
config_bag)
self.cfgimpl_get_settings().validate_mandatory(value,
option_bag)
return value
def find(self,
@ -406,11 +371,10 @@ class SubConfig(object):
:param first: return only one option if True, a list otherwise
:return: find list or an exception if nothing has been found
"""
def _filter_by_value(sconfig_bag):
def _filter_by_value(soption_bag):
try:
value = self.getattr(path,
None,
sconfig_bag)
soption_bag)
except PropertiesOptionError:
return False
if isinstance(value, list):
@ -427,18 +391,19 @@ class SubConfig(object):
_subpath,
config_bag)
for path, option in options:
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = option
if byvalue is not undefined and not _filter_by_value(sconfig_bag):
option_bag = OptionBag()
option_bag.set_option(option,
path,
None,
config_bag)
if byvalue is not undefined and not _filter_by_value(option_bag):
continue
elif sconfig_bag.validate_properties:
elif config_bag.validate_properties:
#remove option with propertyerror, ...
try:
self.unwrap_from_path(path,
sconfig_bag)
self.cfgimpl_get_settings().validate_properties(path,
None,
sconfig_bag)
config_bag)
self.cfgimpl_get_settings().validate_properties(option_bag)
except PropertiesOptionError:
continue
found = True
@ -513,8 +478,11 @@ class SubConfig(object):
path = '.'.join(path.split('.')[:-1])
opt = context.unwrap_from_path(path,
config_bag)
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = opt
soption_bag = OptionBag()
soption_bag.set_option(opt,
path,
None,
config_bag)
if mypath is not None:
if mypath == path:
withoption = None
@ -531,19 +499,24 @@ class SubConfig(object):
pathsvalues,
_currpath,
flatten,
sconfig_bag,
soption_bag,
fullpath=fullpath)
#withoption can be set to None below !
if withoption is None:
for opt in self.cfgimpl_get_description().impl_getchildren(config_bag, context):
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = opt
path = opt.impl_getname()
self._make_sub_dict(path,
name = opt.impl_getname()
path = self._get_subpath(name)
soption_bag = OptionBag()
soption_bag.set_option(opt,
path,
None,
config_bag)
#path = self._get_subpath(name)
self._make_sub_dict(name,
pathsvalues,
_currpath,
flatten,
sconfig_bag,
soption_bag,
fullpath=fullpath)
if _currpath == []:
options = dict(pathsvalues)
@ -555,33 +528,32 @@ class SubConfig(object):
pathsvalues,
_currpath,
flatten,
config_bag,
option_bag,
fullpath=False):
try:
option = config_bag.option
option = option_bag.option
if not option.impl_is_optiondescription() and option.impl_is_master_slaves('slave'):
ret = []
length = self.cfgimpl_get_length_slave(option, config_bag)
length = self.cfgimpl_get_length_slave(option_bag)
if length:
for idx in range(length):
config_bag.properties = None
ret.append(self.getattr(name,
soption_bag = OptionBag()
soption_bag.set_option(option,
option_bag.path,
idx,
config_bag))
elif config_bag.setting_properties:
path = self._get_subpath(name)
self.cfgimpl_get_settings().validate_properties(path,
None,
config_bag)
option_bag.config_bag)
ret.append(self.getattr(name,
soption_bag))
elif option_bag.config_bag.setting_properties:
self.cfgimpl_get_settings().validate_properties(option_bag)
else:
ret = self.getattr(name,
None,
config_bag)
option_bag)
except PropertiesOptionError:
pass
else:
if option.impl_is_optiondescription():
pathsvalues += ret.make_dict(config_bag,
pathsvalues += ret.make_dict(option_bag.config_bag,
flatten=flatten,
_currpath=_currpath + [name],
fullpath=fullpath)
@ -638,12 +610,12 @@ class _CommonConfig(SubConfig):
true_option = option.impl_getopt()
context = self.cfgimpl_get_context()
true_path = true_option.impl_getpath(context)
self, path = context.cfgimpl_get_home_by_path(true_path,
self, path = context.cfgimpl_get_home_by_path(path,
config_bag)
config_bag.option = true_option
else:
true_path = path
config_bag.option = option
#config_bag.option = option
return option
def cfgimpl_get_path(self, dyn=True):
@ -816,25 +788,15 @@ class GroupConfig(_CommonConfig):
return self._impl_children
def cfgimpl_reset_cache(self,
opt,
path,
config_bag,
option_bag,
resetted_opts=None):
if resetted_opts is None:
resetted_opts = []
if isinstance(self, MetaConfig):
super(GroupConfig, self).cfgimpl_reset_cache(opt,
path,
config_bag=config_bag,
super(GroupConfig, self).cfgimpl_reset_cache(option_bag,
resetted_opts=copy(resetted_opts))
for child in self._impl_children:
if config_bag is None:
nconfig_bag = config_bag
else:
nconfig_bag = config_bag.copy('nooption')
child.cfgimpl_reset_cache(opt,
path,
config_bag=nconfig_bag,
child.cfgimpl_reset_cache(option_bag,
resetted_opts=copy(resetted_opts))
def set_value(self,
@ -857,16 +819,21 @@ class GroupConfig(_CommonConfig):
only_config=only_config,
_commit=False))
else:
nconfig_bag = config_bag.copy('nooption')
child.setattr(path,
subconfig, name = child.cfgimpl_get_home_by_path(path,
config_bag)
option = subconfig.cfgimpl_get_description().impl_getchild(name,
config_bag,
child)
option_bag = OptionBag()
option_bag.set_option(option,
path,
index,
value,
nconfig_bag,
config_bag)
child.setattr(value,
option_bag,
_commit=False)
except PropertiesOptionError as err:
ret.append(PropertiesOptionError(err._path,
err._index,
err._config_bag,
ret.append(PropertiesOptionError(err._option_bag,
err.proptype,
err._settings,
err._opt_type,
@ -905,8 +872,6 @@ class GroupConfig(_CommonConfig):
ret = []
for child in self._impl_children:
nconfig_bag = config_bag.copy('nooption')
nconfig_bag.option = child
if isinstance(child, GroupConfig):
ret.extend(child.find_firsts(byname=byname,
bypath=bypath,
@ -1011,59 +976,77 @@ class MetaConfig(GroupConfig):
' cannot be set together'))
opt = self.cfgimpl_get_description().impl_get_opt_by_path(path)
for child in self._impl_children:
nconfig_bag = config_bag.copy('nooption')
nconfig_bag.option = opt
subconfig, name = child.cfgimpl_get_home_by_path(path,
config_bag)
option = subconfig.cfgimpl_get_description().impl_getchild(name,
config_bag,
child)
option_bag = OptionBag()
option_bag.set_option(option,
path,
index,
config_bag)
if force_default_if_same:
if not child.cfgimpl_get_values()._p_.hasvalue(path):
child_value = undefined
else:
child_value = child.getattr(path,
None,
nconfig_bag)
child_value = child.getattr(name,
option_bag)
if force_default or (force_default_if_same and value == child_value):
child.cfgimpl_get_values().reset(path,
nconfig_bag,
child.cfgimpl_get_values().reset(option_bag,
_commit=False)
continue
if force_dont_change_value:
try:
child_value = child.getattr(path,
None,
nconfig_bag)
child_value = child.getattr(name,
option_bag)
if value != child_value:
child.setattr(path,
None,
child_value,
nconfig_bag,
child.setattr(child_value,
option_bag,
_commit=False)
except (PropertiesOptionError, ValueError, SlaveError) as err:
ret.append(err)
nconfig_bag = config_bag.copy('nooption')
try:
self.setattr(path,
subconfig, name = self.cfgimpl_get_home_by_path(path,
config_bag)
option = subconfig.cfgimpl_get_description().impl_getchild(name,
config_bag,
self)
option_bag = OptionBag()
option_bag.set_option(option,
path,
index,
value,
nconfig_bag,
_commit=_commit)
config_bag)
self.setattr(value,
option_bag,
_commit=False)
except (PropertiesOptionError, ValueError, SlaveError) as err:
ret.append(err)
return ret
def reset(self, path, config_bag):
#FIXME not working with DynSymLinkOption
#FIXME fonctionne avec sous metaconfig ??
opt = self.cfgimpl_get_description().impl_get_opt_by_path(path)
config_bag.option = opt
config_bag.validate = False
for child in self._impl_children:
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = opt
child.cfgimpl_get_values().reset(path,
sconfig_bag,
_commit=False)
self.cfgimpl_get_values().reset(path,
def reset(self,
path,
config_bag):
rconfig_bag = ConfigBag(config=config_bag.config,
_setting_properties=config_bag._setting_properties,
force_permissive=config_bag.force_permissive,
force_unrestraint=config_bag.force_unrestraint,
_validate=False)
subconfig, name = self.cfgimpl_get_home_by_path(path,
config_bag)
option = subconfig.cfgimpl_get_description().impl_getchild(name,
config_bag,
self)
option_bag = OptionBag()
option_bag.set_option(option,
path,
option,
rconfig_bag)
for child in self._impl_children:
child.cfgimpl_get_values().reset(option_bag,
_commit=False)
self.cfgimpl_get_values().reset(option_bag)
def new_config(self,
session_id,

24
tiramisu/error.py
View file

@ -53,31 +53,27 @@ def display_list(lst, separator='and', add_quote=False):
class PropertiesOptionError(AttributeError):
"attempt to access to an option with a property that is not allowed"
def __init__(self,
path,
index,
config_bag,
option_bag,
proptype,
settings,
opt_type=None,
requires=None,
name=None,
orig_opt=None):
self._path = path
self._index = index
if opt_type:
self._opt_type = opt_type
self._requires = requires
self._name = name
self._orig_opt = orig_opt
else:
if config_bag.option.impl_is_optiondescription():
if option_bag.option.impl_is_optiondescription():
self._opt_type = 'optiondescription'
else:
self._opt_type = 'option'
self._requires = config_bag.option.impl_getrequires()
self._name = config_bag.option.impl_get_display_name()
self._requires = option_bag.option.impl_getrequires()
self._name = option_bag.option.impl_get_display_name()
self._orig_opt = None
self._config_bag = config_bag.copy()
self._option_bag = option_bag
self.proptype = proptype
self._settings = settings
self.msg = None
@ -90,12 +86,8 @@ class PropertiesOptionError(AttributeError):
#this part is a bit slow, so only execute when display
if self.msg:
return self.msg
req = self._settings.apply_requires(self._path,
self._requires,
self._index,
True,
self._config_bag,
self._name)
req = self._settings.apply_requires(self._option_bag,
True)
#if req != {} or self._orig_opt is not None:
if req != {}:
only_one = len(req) == 1
@ -123,7 +115,7 @@ class PropertiesOptionError(AttributeError):
self._name,
prop_msg,
msg))
del self._path, self._index, self._requires, self._opt_type, self._name, self._config_bag
del self._requires, self._opt_type, self._name, self._option_bag
del self._settings, self._orig_opt
return self.msg

22
tiramisu/option/choiceoption.py
View file

@ -81,22 +81,26 @@ class ChoiceOption(Option):
warnings_only=warnings_only)
def impl_get_values(self,
config_bag,
option_bag,
current_opt=undefined):
if current_opt is undefined:
current_opt = self
#FIXME cache? but in context...
values = self._choice_values
if isinstance(values, FunctionType):
if config_bag is undefined:
if option_bag is undefined:
values = undefined
else:
if option_bag.config_bag == undefined:
config = undefined
else:
config = option_bag.config_bag.config
values = carry_out_calculation(current_opt,
config_bag.config,
values,
getattr(self, '_choice_values_params', {}),
None,
config_bag)
context=config,
callback=values,
callback_params=getattr(self, '_choice_values_params', {}),
index=None,
option_bag=option_bag)
if values is not undefined and not isinstance(values, list):
raise ConfigError(_('calculated values for {0} is not a list'
'').format(self.impl_getname()))
@ -105,9 +109,9 @@ class ChoiceOption(Option):
def _validate(self,
value,
config_bag,
option_bag,
current_opt=undefined):
values = self.impl_get_values(config_bag,
values = self.impl_get_values(option_bag,
current_opt=current_opt)
if values is not undefined and not value in values:
if len(values) == 1:

12
tiramisu/option/dynoptiondescription.py
View file

@ -72,14 +72,14 @@ class DynOptionDescription(OptionDescription):
'').format(self.impl_get_display_name()))
def _impl_get_suffixes(self,
config_bag):
option_bag):
callback, callback_params = self.impl_get_callback()
values = carry_out_calculation(self,
config_bag.config,
option_bag.config_bag.config,
callback,
callback_params,
None,
config_bag)
option_bag)
if not isinstance(values, list):
raise ValueError(_('DynOptionDescription callback for option "{}", is not a list ({})'
'').format(self.impl_get_display_name(), values))
@ -92,9 +92,9 @@ class DynOptionDescription(OptionDescription):
self.impl_get_display_name()))
return values
def get_syndynoptiondescriptions(self, config_bag):
subpath = self.impl_getpath(config_bag.config).rsplit('.', 1)[0]
for suffix in self._impl_get_suffixes(config_bag):
def get_syndynoptiondescriptions(self, option_bag):
subpath = self.impl_getpath(option_bag.config_bag.config).rsplit('.', 1)[0]
for suffix in self._impl_get_suffixes(option_bag):
yield SynDynOptionDescription(self,
subpath,
suffix)

38
tiramisu/option/masterslave.py
View file

@ -24,7 +24,7 @@ from itertools import chain
from ..i18n import _
from ..setting import groups, undefined
from ..setting import groups, undefined, OptionBag, ConfigBag
from .optiondescription import OptionDescription
from .option import Option
from ..error import SlaveError, PropertiesOptionError
@ -104,35 +104,49 @@ class MasterSlaves(OptionDescription):
def reset(self,
values,
config_bag,
option_bag,
_commit=True):
config_bag = ConfigBag(config=option_bag.config_bag.config,
_setting_properties=option_bag.config_bag._setting_properties,
force_permissive=option_bag.config_bag.force_permissive,
force_unrestraint=option_bag.config_bag.force_unrestraint,
_validate=False)
for slave in self.getslaves():
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = slave
sconfig_bag.validate = False
slave_path = slave.impl_getpath(values._getcontext())
values.reset(slave_path,
sconfig_bag,
soption_bag = OptionBag()
soption_bag.set_option(slave,
slave_path,
None,
config_bag)
values.reset(soption_bag,
_commit=_commit)
def pop(self,
values,
index,
config_bag,
option_bag,
slaves=undefined):
context = values._getcontext()
if slaves is undefined:
slaves = self.getslaves()
config_bag = ConfigBag(config=option_bag.config_bag.config,
_setting_properties=None,
force_permissive=option_bag.config_bag.force_permissive,
force_unrestraint=option_bag.config_bag.force_unrestraint,
_validate=False)
for slave in slaves:
slave_path = slave.impl_getpath(context)
slavelen = values._p_.get_max_length(slave_path)
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = slave
if not values.is_default_owner(slave_path,
soption_bag = OptionBag()
soption_bag.set_option(slave,
slave_path,
index,
config_bag,
config_bag)
# do not check force_default_on_freeze
soption_bag.properties = {}
if not values.is_default_owner(soption_bag,
validate_meta=False):
if slavelen > index:
values._p_.resetvalue_index(slave_path,

11
tiramisu/option/netmaskoption.py
View file

@ -95,9 +95,15 @@ class NetmaskOption(Option):
if make_net and ip.prefixlen() != 32:
val_ip = IP(val_ipnetwork)
if ip.net() == val_ip:
if current_opt == opts[1]:
msg = _('this is a network with netmask "{0}" ("{1}")')
else:
msg = _('this is a network with {2} "{0}" ("{1}")')
if ip.broadcast() == val_ip:
if current_opt == opts[1]:
msg = _('this is a broadcast with netmask "{0}" ("{1}")')
else:
msg = _('this is a broadcast with {2} "{0}" ("{1}")')
except ValueError:
if not make_net:
@ -106,5 +112,10 @@ class NetmaskOption(Option):
else:
raise ValueError(_('with {2} "{0}" ("{1}")').format(val_ipnetwork, opts[1].impl_get_display_name(), typ))
if msg is not None:
if current_opt == opts[1]:
raise ValueError(msg.format(val_netmask,
opts[1].impl_get_display_name()))
else:
raise ValueError(msg.format(val_ipnetwork,
opts[0].impl_get_display_name(),
typ))

166
tiramisu/option/option.py
View file

@ -25,7 +25,7 @@ import weakref
from .baseoption import OnlyOption, submulti, STATIC_TUPLE
from .symlinkoption import DynSymLinkOption
from ..i18n import _
from ..setting import log, undefined, debug
from ..setting import log, undefined, debug, OptionBag, ConfigBag
from ..autolib import carry_out_calculation
from ..error import (ConfigError, ValueWarning, PropertiesOptionError,
display_list)
@ -145,9 +145,13 @@ class Option(OnlyOption):
_setattr(self, '_default_multi', default_multi)
if unique is not undefined:
_setattr(self, '_unique', unique)
option_bag = OptionBag()
option_bag.set_option(self,
undefined,
None,
undefined)
self.impl_validate(default,
is_multi=is_multi,
config_bag=undefined)
option_bag)
if (is_multi and default != []) or \
(not is_multi and default is not None):
if is_multi:
@ -180,34 +184,25 @@ class Option(OnlyOption):
def impl_validate(self,
value,
config_bag,
option_bag,
context=undefined,
force_index=None,
current_opt=undefined,
is_multi=None,
check_error=True,
multi=None):
check_error=True):
"""
:param value: the option's value
:param context: Config's context
:type context: :class:`tiramisu.config.Config`
:type validate: boolean
:param force_index: if multi, value has to be a list
not if force_index is not None
:type force_index: integer
"""
if current_opt is undefined:
current_opt = self
if option_bag:
config_bag = option_bag.config_bag
force_index = option_bag.index
else:
config_bag = undefined
force_index = None
if check_error and config_bag is not undefined and \
not config_bag.validate:
# just to check propertieserror
self.valid_consistency(current_opt,
self.valid_consistency(option_bag,
value,
context,
force_index,
check_error,
config_bag)
check_error)
return
def _is_not_unique(value):
@ -233,13 +228,13 @@ class Option(OnlyOption):
args.insert(0, ParamValue(val))
validator_params_ = Params(tuple(args), kwargs)
# Raise ValueError if not valid
carry_out_calculation(current_opt,
carry_out_calculation(option_bag.ori_option,
context=context,
callback=validator,
callback_params=validator_params_,
index=_index,
option_bag=option_bag,
orig_value=value,
config_bag=config_bag,
is_validator=True)
def do_validation(_value,
@ -251,13 +246,9 @@ class Option(OnlyOption):
if _value is not None:
if check_error:
# option validation
if config_bag is undefined:
setting_properties = None
else:
setting_properties = config_bag.setting_properties
self._validate(_value,
config_bag,
current_opt)
option_bag,
option_bag.ori_option)
if ((check_error and not is_warnings_only) or
(not check_error and is_warnings_only)):
calculation_validator(_value,
@ -265,13 +256,13 @@ class Option(OnlyOption):
self._second_level_validation(_value,
is_warnings_only)
if is_multi is None:
is_multi = self.impl_is_multi()
#if is_multi is None:
# is_multi = self.impl_is_multi()
is_warnings_only = getattr(self, '_warnings_only', False)
try:
val = value
if not is_multi:
if not self.impl_is_multi():
do_validation(val, None)
elif force_index is not None:
if self.impl_is_submulti():
@ -282,14 +273,6 @@ class Option(OnlyOption):
do_validation(val,
force_index)
else:
if multi is not None and self.impl_is_unique() and value in multi:
if not self.impl_is_submulti() and len(multi) - 1 >= force_index:
lst = list(multi)
lst.pop(force_index)
else:
lst = multi
if value in lst:
raise ValueError(_('this value is not uniq'))
do_validation(val,
force_index)
elif not isinstance(value, list):
@ -309,17 +292,15 @@ class Option(OnlyOption):
do_validation(val,
idx)
self.valid_consistency(current_opt,
self.valid_consistency(option_bag,
value,
context,
force_index,
check_error,
config_bag)
check_error)
except ValueError as err:
if debug: # pragma: no cover
log.debug('do_validation: value: {0}, index: {1}:'
' {2}'.format(val,
_index,
force_index,
err),
exc_info=True)
if is_warnings_only:
@ -443,15 +424,16 @@ class Option(OnlyOption):
all_cons_opts,
params)
#validate default value when add consistency
#FIXME validation!
self.impl_validate(self.impl_getdefault(),
option_bag = OptionBag()
option_bag.set_option(self,
undefined,
None,
undefined)
self.impl_validate(self.impl_getdefault(),
undefined,
option_bag)
self.impl_validate(self.impl_getdefault(),
option_bag,
check_error=False)
#FIXME
#if err:
# self._del_consistency()
if func != '_cons_not_equal':
#consistency could generate warnings or errors
self._has_dependency = True
@ -465,37 +447,45 @@ class Option(OnlyOption):
opt._add_dependency(self)
def valid_consistency(self,
option,
option_bag,
value,
context,
index,
check_error,
config_bag):
check_error):
if context is not undefined:
descr = context.cfgimpl_get_description()
# no consistency found at all
if descr._cache_consistencies is None:
return
# get consistencies for this option
if isinstance(option, DynSymLinkOption):
consistencies = descr._cache_consistencies.get(option.impl_getopt())
if isinstance(option_bag.option, DynSymLinkOption):
consistencies = descr._cache_consistencies.get(option_bag.option.impl_getopt())
else:
consistencies = descr._cache_consistencies.get(option)
consistencies = descr._cache_consistencies.get(option_bag.option)
else:
# is no context, get consistencies in option
consistencies = option.get_consistencies()
if consistencies is not None:
consistencies = option_bag.option.get_consistencies()
if consistencies:
if option_bag.config_bag is undefined:
cconfig_bag = undefined
elif option_bag.config_bag.force_permissive != True:
cconfig_bag = ConfigBag(config=option_bag.config_bag.config,
_setting_properties=option_bag.config_bag._setting_properties,
force_permissive=True,
force_unrestraint=option_bag.config_bag.force_unrestraint,
_validate=option_bag.config_bag._validate)
else:
cconfig_bag = option_bag.config_bag
for cons_id, func, all_cons_opts, params in consistencies:
warnings_only = params.get('warnings_only', False)
if (warnings_only and not check_error) or (not warnings_only and check_error):
transitive = params.get('transitive', True)
#all_cons_opts[0] is the option where func is set
if isinstance(option, DynSymLinkOption):
if isinstance(option_bag.ori_option, DynSymLinkOption):
opts = []
for opt in all_cons_opts:
opts.append(DynSymLinkOption(opt(),
option._rootpath,
option._suffix))
option_bag.ori_option._rootpath,
option_bag.ori_option._suffix))
wopt = opts[0]
else:
opts = all_cons_opts
@ -503,25 +493,23 @@ class Option(OnlyOption):
wopt.launch_consistency(self,
func,
cons_id,
option,
option_bag,
value,
context,
index,
opts,
warnings_only,
transitive,
config_bag)
cconfig_bag)
def _get_consistency_value(self,
orig_option,
option_bag,
current_option,
index,
cons_id,
context,
config_bag,
value,
transitive,
func):
index = option_bag.index
if func in ALLOWED_CONST_LIST:
index = None
index_ = None
@ -529,7 +517,7 @@ class Option(OnlyOption):
index_ = None
else:
index_ = index
if orig_option == current_option:
if option_bag.ori_option == current_option:
# orig_option is current option
# we have already value, so use it
return value
@ -537,14 +525,18 @@ class Option(OnlyOption):
#if no context get default value
return current_option.impl_getdefault()
#otherwise calculate value
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = current_option
sconfig_bag.fromconsistency.append(cons_id)
sconfig_bag.force_permissive = True
path = current_option.impl_getpath(context)
opt_value = context.getattr(path,
coption_bag = OptionBag()
coption_bag.set_option(current_option,
path,
index_,
sconfig_bag)
config_bag)
cons_ids = option_bag.fromconsistency.copy()
cons_ids.append(cons_id)
coption_bag.fromconsistency = cons_ids
opt_value = context.getattr(path,
coption_bag)
if index_ is None and index is not None:
if len(opt_value) <= index:
opt_value = current_option.impl_getdefault_multi()
@ -556,10 +548,9 @@ class Option(OnlyOption):
current_opt,
func,
cons_id,
option,
option_bag,
value,
context,
index,
opts,
warnings_only,
transitive,
@ -583,9 +574,7 @@ class Option(OnlyOption):
:param transitive: propertyerror is transitive
:type transitive: `boolean`
"""
#if context is not undefined:
# descr = context.cfgimpl_get_description()
if config_bag is not undefined and cons_id in config_bag.fromconsistency:
if cons_id in option_bag.fromconsistency:
return
all_cons_vals = []
all_cons_opts = []
@ -595,29 +584,28 @@ class Option(OnlyOption):
opt = opt()
is_multi = False
try:
opt_value = self._get_consistency_value(option,
opt_value = self._get_consistency_value(option_bag,
opt,
index,
cons_id,
context,
config_bag,
value,
transitive,
func)
except PropertiesOptionError as err:
if debug: # pragma: no cover
log.debug('propertyerror in launch_consistency: {0}'.format(err))
if transitive:
err.set_orig_opt(option)
err.set_orig_opt(option_bag.option)
raise err
else:
if opt.impl_is_multi() and index is None and func not in ALLOWED_CONST_LIST:
if opt.impl_is_multi() and option_bag.index is None and \
func not in ALLOWED_CONST_LIST:
len_value = len(opt_value)
if length is not None and length != len_value:
if context is undefined:
return
raise ValueError(_('unexpected length of "{}" in constency "{}", should be "{}"'
'').format(len(opt_value),
raise ValueError(_('unexpected length of "{}" in constency "{}", '
'should be "{}"').format(len(opt_value),
opt.impl_get_display_name(),
length))
else:

47
tiramisu/option/optiondescription.py
View file

@ -22,7 +22,7 @@ from copy import copy
from ..i18n import _
from ..setting import ConfigBag, groups, undefined, owners
from ..setting import ConfigBag, OptionBag, groups, undefined, owners
from .baseoption import BaseOption, OnlyOption
from .option import ALLOWED_CONST_LIST, DynSymLinkOption
from .syndynoptiondescription import SynDynOptionDescription
@ -173,11 +173,14 @@ class CacheOptionDescription(BaseOption):
'"force_store_value" property').format(
option.impl_get_display_name()))
if not values._p_.hasvalue(subpath):
config_bag = ConfigBag(config=context, option=option)
config_bag.properties = frozenset()
value = values.getvalue(subpath,
config_bag = ConfigBag(config=context)
option_bag = OptionBag()
option_bag.set_option(option,
subpath,
None,
config_bag)
option_bag.properties = frozenset()
value = values.getvalue(option_bag)
value_setted = True
values._p_.setvalue(subpath,
value,
@ -224,13 +227,14 @@ class OptionDescriptionWalk(CacheOptionDescription):
__slots__ = ('_children',)
def build_dynoptions(self,
option,
config_bag):
option_bag):
option = option_bag.option
dynopt = option.getsubdyn()
rootpath = self.impl_get_path_by_opt(dynopt)
ori_index = len(rootpath) + 1
subpaths = [rootpath] + option.impl_getpath(config_bag.config)[ori_index:].split('.')[:-1]
for suffix in dynopt._impl_get_suffixes(config_bag):
subpaths = [rootpath] + option.impl_getpath(
option_bag.config_bag.config)[ori_index:].split('.')[:-1]
for suffix in dynopt._impl_get_suffixes(option_bag):
subpath = '.'.join([subp + suffix for subp in subpaths])
if isinstance(option, OnlyOption):
yield DynSymLinkOption(option,
@ -257,7 +261,12 @@ class OptionDescriptionWalk(CacheOptionDescription):
name = option.impl_getname()
if option.issubdyn():
if byname.startswith(name):
for doption in self.build_dynoptions(option, config_bag):
option_bag = OptionBag()
option_bag.set_option(option,
path,
None,
config_bag)
for doption in self.build_dynoptions(option_bag):
if byname == doption.impl_getname():
dpath = doption.impl_getpath(config_bag.config)
return (dpath, doption)
@ -319,9 +328,12 @@ class OptionDescriptionWalk(CacheOptionDescription):
subpath = ''
else:
subpath = self.impl_getpath(config_bag.config)
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = child
for suffix in child._impl_get_suffixes(sconfig_bag):
option_bag = OptionBag()
option_bag.set_option(child,
subpath,
None,
config_bag)
for suffix in child._impl_get_suffixes(option_bag):
yield SynDynOptionDescription(child,
subpath,
suffix)
@ -339,11 +351,16 @@ class OptionDescriptionWalk(CacheOptionDescription):
subconfig,
config_bag):
for child in self._impl_st_getchildren(only_dyn=True):
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = child
#sconfig_bag = config_bag.copy('nooption')
#sconfig_bag.option = child
cname = child.impl_getname()
if name.startswith(cname):
for value in child._impl_get_suffixes(sconfig_bag):
option_bag = OptionBag()
option_bag.set_option(child,
subconfig.cfgimpl_get_path(),
None,
config_bag)
for value in child._impl_get_suffixes(option_bag):
if name == cname + value:
return SynDynOptionDescription(child,
subconfig.cfgimpl_get_path(),

29
tiramisu/option/symlinkoption.py
View file

@ -20,7 +20,7 @@
# ____________________________________________________________
from .baseoption import OnlyOption
from ..i18n import _
from ..setting import undefined
from ..setting import undefined, OptionBag
class SymLinkOption(OnlyOption):
@ -104,22 +104,21 @@ class DynSymLinkOption(object):
def impl_validate(self,
value,
config_bag,
option_bag,
context=undefined,
force_index=None,
current_opt=undefined,
is_multi=None,
check_error=True,
multi=None):
# add current_opt !
check_error=True):
context = option_bag.config_bag.config
soption_bag = OptionBag()
soption_bag.set_option(self._opt,
self.impl_getpath(context),
option_bag.index,
option_bag.config_bag)
soption_bag.ori_option = option_bag.option
soption_bag.fromconsistency = option_bag.fromconsistency.copy()
self._opt.impl_validate(value,
config_bag,
context,
force_index,
current_opt=self,
is_multi=is_multi,
check_error=check_error,
multi=multi)
soption_bag,
context=context,
check_error=check_error)
def impl_is_dynsymlinkoption(self):
return True

326
tiramisu/setting.py
View file

@ -117,77 +117,99 @@ debug = False
static_set = frozenset()
class ConfigBag(object):
__slots__ = ('default',
'config',
'option',
'ori_option',
'properties',
'setting_properties',
'force_permissive',
'force_unrestraint',
'trusted_cached_properties',
'fromconsistency',
'_validator'
class OptionBag:
__slots__ = ('option', # current option
'path',
'index',
'config_bag',
'ori_option', # original option (for example useful for symlinkoption)
'properties', # properties of current option
'apply_requires',
'fromconsistency' # history for consistency
)
def __init__(self):
self.option = None
self.fromconsistency = []
def set_option(self,
option,
path,
index,
config_bag):
if self.option != None:
raise Exception('hu?')
if path is None:
path = config_bag.config.cfgimpl_get_description().impl_get_path_by_opt(option)
self.path = path
self.index = index
self.option = option
self.config_bag = config_bag
def __getattr__(self, key):
if key == 'properties':
settings = self.config_bag.config.cfgimpl_get_settings()
self.properties = settings.getproperties(self, apply_requires=self.apply_requires)
return self.properties
elif key == 'ori_option':
return self.option
elif key == 'apply_requires':
return True
raise KeyError('unknown key {} for OptionBag'.format(key))
class ConfigBag:
__slots__ = ('config', # link to the current config (context)
'_setting_properties', # properties for current config
'force_permissive', # force permissive
'force_unrestraint', # do not validate properties
'_validate', # validate
)
def __init__(self, config, **kwargs):
self.default = {'force_permissive': False,
'force_unrestraint': False,
'trusted_cached_properties': True,
}
self.force_permissive = False
self.force_unrestraint = False
self.config = config
self._validator = True
self.fromconsistency = []
self._validate = True
for key, value in kwargs.items():
if value != self.default.get(key):
setattr(self, key, value)
def __getattr__(self, key):
if key == 'validate_properties':
return not self.force_unrestraint
if key == 'validate':
if self.setting_properties is not None:
return 'validator' in self.setting_properties
return self._validator
if self._validate and self._setting_properties is not None:
return 'validator' in self._setting_properties
return self._validate
if key == 'setting_properties':
if self.force_unrestraint:
return None
self.setting_properties = self.config.cfgimpl_get_settings().get_context_properties()
return self.setting_properties
return self._setting_properties
if key == '_setting_properties':
self._setting_properties = self.config.cfgimpl_get_settings().get_context_properties()
if self._validate is False:
self._setting_properties = self._setting_properties - {'validator'}
return self._setting_properties
if key not in self.__slots__:
raise KeyError('unknown key {}'.format(key))
return self.default.get(key)
raise KeyError('unknown key {} for ConfigBag'.format(key))
return None
def __setattr__(self, key, value):
if key == 'validate':
if self.setting_properties is not None:
if value is False:
self.setting_properties = frozenset(set(self.setting_properties) - {'validator'})
else:
self.setting_properties = frozenset(set(self.setting_properties) | {'validator'})
else:
self._validator = value
try:
del self._setting_properties
except AttributeError:
pass
self._validate = value
else:
super().__setattr__(key, value)
def delete(self, key):
try:
return self.__delattr__(key)
except AttributeError:
pass
def copy(self, filters='all'):
def copy(self):
kwargs = {}
for key in self.__slots__:
if filters == 'nooption' and (key.startswith('option') or \
key == 'properties'):
continue
if key == 'fromconsistency':
if key == 'fromconsistency' and self.fromconsistency != []:
kwargs['fromconsistency'] = copy(self.fromconsistency)
elif key != 'default':
value = getattr(self, key)
if value != self.default.get(key):
kwargs[key] = value
else:
kwargs[key] = getattr(self, key)
return ConfigBag(**kwargs)
@ -357,13 +379,14 @@ class Settings(object):
return props
def getproperties(self,
path,
index,
config_bag,
option_bag,
apply_requires=True):
"""
"""
opt = config_bag.option
opt = option_bag.option
config_bag = option_bag.config_bag
path = option_bag.path
index = option_bag.index
if opt.impl_is_symlinkoption():
opt = opt.impl_getopt()
path = opt.impl_getpath(self._getcontext())
@ -384,17 +407,11 @@ class Settings(object):
props = self._p_.getproperties(path,
opt.impl_getproperties())
else:
props = meta.cfgimpl_get_settings().getproperties(path,
index,
config_bag,
props = meta.cfgimpl_get_settings().getproperties(option_bag,
apply_requires)
if apply_requires:
props |= self.apply_requires(path,
opt.impl_getrequires(),
index,
False,
config_bag,
opt.impl_get_display_name())
props |= self.apply_requires(option_bag,
False)
props -= self.getpermissive(opt,
path)
if apply_requires:
@ -421,12 +438,8 @@ class Settings(object):
return self._pp_.getpermissive(path)
def apply_requires(self,
path,
current_requires,
index,
readable,
config_bag,
name):
option_bag,
readable):
"""carries out the jit (just in time) requirements between options
a requirement is a tuple of this form that comes from the option's
@ -470,7 +483,7 @@ class Settings(object):
:param path: the option's path in the config
:type path: str
"""
#current_requires = opt.impl_getrequires()
current_requires = option_bag.option.impl_getrequires()
# filters the callbacks
if readable:
@ -489,32 +502,38 @@ class Settings(object):
breaked = False
for option, expected in exps:
reqpath = option.impl_getpath(context)
#FIXME c'est un peut tard !
if reqpath.startswith(path + '.'):
#FIXME c'est un peu tard !
if reqpath.startswith(option_bag.path + '.'):
raise RequirementError(_("malformed requirements "
"imbrication detected for option:"
" '{0}' with requirement on: "
"'{1}'").format(path, reqpath))
"'{1}'").format(option_bag.path, reqpath))
idx = None
is_indexed = False
if option.impl_is_master_slaves('slave'):
idx = index
idx = option_bag.index
elif option.impl_is_multi():
is_indexed = True
sconfig_bag = config_bag.copy('nooption')
if config_bag.option == option:
sconfig_bag.setting_properties = None
sconfig_bag.force_unrestraint= False
sconfig_bag.validate = False
else:
sconfig_bag.force_permissive = True
sconfig_bag.option = option
config_bag = ConfigBag(config=option_bag.config_bag.config,
_setting_properties=option_bag.config_bag._setting_properties,
force_permissive=True,
force_unrestraint=option_bag.config_bag.force_unrestraint,
_validate=option_bag.config_bag._validate)
soption_bag = OptionBag()
soption_bag.set_option(option,
reqpath,
idx,
config_bag)
soption_bag.config_bag.force_permissive = True
if option_bag.option == option:
soption_bag.config_bag.force_unrestraint = True
soption_bag.config_bag.validate = False
soption_bag.apply_requires = False
try:
value = context.getattr(reqpath,
idx,
sconfig_bag)
soption_bag)
if is_indexed:
value = value[index]
value = value[option_bag.index]
except PropertiesOptionError as err:
properties = err.proptype
if not transitive:
@ -532,19 +551,15 @@ class Settings(object):
prop_msg = _('properties')
raise RequirementError(_('cannot access to option "{0}" because '
'required option "{1}" has {2} {3}'
'').format(name,
'').format(option_bag.option.impl_get_display_name(),
option.impl_get_display_name(),
prop_msg,
display_list(list(properties), add_quote=True)))
# transitive action, add action
if operator != 'and':
if readable:
for msg in self.apply_requires(err._path,
err._requires,
err._index,
True,
err._config_bag,
err._name).values():
for msg in self.apply_requires(err._option_bag,
True).values():
calc_properties.setdefault(action, []).extend(msg)
else:
calc_properties.add(action)
@ -587,23 +602,25 @@ class Settings(object):
def setproperties(self,
path,
properties,
config_bag):
option_bag):
"""save properties for specified path
(never save properties if same has option properties)
"""
# should have index !!!
if self._getcontext().cfgimpl_get_meta() is not None:
raise ConfigError(_('cannot change property with metaconfig'))
if path is not None and config_bag.option.impl_getrequires() is not None:
not_allowed_props = properties & getattr(config_bag.option, '_calc_properties', static_set)
if path is not None and option_bag.option.impl_getrequires() is not None:
not_allowed_props = properties & \
getattr(option_bag.option, '_calc_properties', static_set)
if not_allowed_props:
raise ValueError(_('cannot set property {} for option "{}" this property is calculated'
'').format(display_list(list(not_allowed_props), add_quote=True),
config_bag.option.impl_get_display_name()))
if config_bag is None:
raise ValueError(_('cannot set property {} for option "{}" this property is '
'calculated').format(display_list(list(not_allowed_props),
add_quote=True),
option_bag.option.impl_get_display_name()))
if option_bag is None:
opt = None
else:
opt = config_bag.option
opt = option_bag.option
if opt and opt.impl_is_symlinkoption():
raise TypeError(_("can't assign property to the symlinkoption \"{}\""
"").format(opt.impl_get_display_name()))
@ -616,21 +633,20 @@ class Settings(object):
self._p_.setproperties(path,
properties)
#values too because of slave values could have a PropertiesOptionError has value
self._getcontext().cfgimpl_reset_cache(opt,
path,
config_bag)
self._getcontext().cfgimpl_reset_cache(option_bag)
if option_bag is not None:
try:
del option_bag.properties
except AttributeError:
pass
def set_context_permissive(self,
permissive):
self.setpermissive(None,
None,
None,
permissive)
def setpermissive(self,
opt,
path,
config_bag,
option_bag,
permissives):
"""
enables us to put the permissives in the storage
@ -645,51 +661,55 @@ class Settings(object):
raise ConfigError(_('cannot change permissive with metaconfig'))
if not isinstance(permissives, frozenset):
raise TypeError(_('permissive must be a frozenset'))
if option_bag is not None:
opt = option_bag.option
if opt and opt.impl_is_symlinkoption():
raise TypeError(_("can't assign permissive to the symlinkoption \"{}\""
"").format(opt.impl_get_display_name()))
path = option_bag.path
else:
path = None
forbidden_permissives = FORBIDDEN_SET_PERMISSIVES & permissives
if forbidden_permissives:
raise ConfigError(_('cannot add those permissives: {0}').format(
' '.join(forbidden_permissives)))
self._pp_.setpermissive(path, permissives)
self._getcontext().cfgimpl_reset_cache(opt,
path,
config_bag)
if option_bag is not None:
self._getcontext().cfgimpl_reset_cache(option_bag)
#____________________________________________________________
# reset methods
def reset(self,
opt,
path,
config_bag,
all_properties=False):
option_bag):
# all_properties=False):
if self._getcontext().cfgimpl_get_meta() is not None:
raise ConfigError(_('cannot change property with metaconfig'))
if option_bag is None:
opt = None
else:
opt = option_bag.option
if opt and opt.impl_is_symlinkoption():
raise TypeError(_("can't reset properties to the symlinkoption \"{}\""
"").format(opt.impl_get_display_name()))
if all_properties and (path or opt):
raise ValueError(_('opt and all_properties must not be set '
'together in reset'))
if all_properties:
self._p_.reset_all_properties()
#if all_properties and (path or opt):
# raise ValueError(_('opt and all_properties must not be set '
# 'together in reset'))
#if all_properties:
# self._p_.reset_all_properties()
else:
if opt is not None and path is None:
path = opt.impl_getpath(self._getcontext())
if opt is not None:
path = option_bag.path
else:
path = None
self._p_.delproperties(path)
self._getcontext().cfgimpl_reset_cache(opt,
path,
config_bag)
self._getcontext().cfgimpl_reset_cache(option_bag)
#____________________________________________________________
# validate properties
def validate_properties(self,
path,
index,
config_bag):
option_bag):
"""
validation upon the properties related to `opt`
@ -697,70 +717,56 @@ class Settings(object):
:param force_permissive: behaves as if the permissive property
was present
"""
opt = config_bag.option
# calc properties
self_properties = config_bag.properties
if self_properties is None:
self_properties = self.getproperties(path,
index,
config_bag)
config_bag.properties = self_properties
self_properties = option_bag.properties
config_bag = option_bag.config_bag
properties = self_properties & config_bag.setting_properties - {'frozen', 'mandatory', 'empty'}
# remove permissive properties
if (config_bag.force_permissive is True or 'permissive' in config_bag.setting_properties) and properties:
if (config_bag.force_permissive is True or \
'permissive' in config_bag.setting_properties) and properties:
# remove global permissive if need
properties -= self.get_context_permissive()
# at this point an option should not remain in properties
if properties != frozenset():
raise PropertiesOptionError(path,
index,
config_bag,
raise PropertiesOptionError(option_bag,
properties,
self)
def validate_mandatory(self,
path,
index,
value,
config_bag):
option_bag):
values = self._getcontext().cfgimpl_get_values()
opt = config_bag.option
opt = option_bag.option
config_bag = option_bag.config_bag
is_mandatory = False
if config_bag.setting_properties and 'mandatory' in config_bag.setting_properties:
if (config_bag.force_permissive is True or 'permissive' in config_bag.setting_properties) and \
'mandatory' in self.get_context_permissive():
pass
elif 'mandatory' in config_bag.properties and values.isempty(opt,
elif 'mandatory' in option_bag.properties and values.isempty(opt,
value,
index=index):
index=option_bag.index):
is_mandatory = True
if 'empty' in config_bag.properties and values.isempty(opt,
if 'empty' in option_bag.properties and values.isempty(opt,
value,
force_allow_empty_list=True,
index=index):
index=option_bag.index):
is_mandatory = True
if is_mandatory:
raise PropertiesOptionError(path,
index,
config_bag,
raise PropertiesOptionError(option_bag,
['mandatory'],
self)
def validate_frozen(self,
path,
index,
config_bag):
if config_bag.setting_properties and \
('everything_frozen' in config_bag.setting_properties or
'frozen' in config_bag.properties) and \
not ((config_bag.force_permissive is True or
'permissive' in config_bag.setting_properties) and
option_bag):
if option_bag.config_bag.setting_properties and \
('everything_frozen' in option_bag.config_bag.setting_properties or
'frozen' in option_bag.properties) and \
not ((option_bag.config_bag.force_permissive is True or
'permissive' in option_bag.config_bag.setting_properties) and
'frozen' in self.get_context_permissive()):
raise PropertiesOptionError(path,
index,
config_bag,
raise PropertiesOptionError(option_bag,
['frozen'],
self)
return False

9
tiramisu/storage/util.py
View file

@ -44,13 +44,14 @@ class Cache(DictCache):
_display_classname(self),
id(self)))
self._setcache(path, index, val, time())
if DEBUG:
print('not setcache {} with index {} and value {} in {} ({})'.format(path,
elif DEBUG:
print('not setcache {} with index {} and value {} and props {} and {} in {} ({})'.format(path,
index,
val,
props,
self_props,
_display_classname(self),
id(self)))
return
def getcache(self,
path,
@ -119,5 +120,5 @@ class Cache(DictCache):
example: {'path1': {'index1': ('value1', 'time1')}, 'path2': {'index2': ('value2', 'time2', )}}
"""
if DEBUG:
print('get_chached', self._cache)
print('get_chached {} for {} ({})'.format(self._cache, _display_classname(self), id(self)))
return self._get_cached()

460
tiramisu/value.py
View file

@ -17,7 +17,7 @@
# ____________________________________________________________
import weakref
from .error import ConfigError, PropertiesOptionError
from .setting import owners, expires_time, undefined, forbidden_owners
from .setting import owners, expires_time, undefined, forbidden_owners, OptionBag, ConfigBag
from .autolib import carry_out_calculation
from .i18n import _
@ -63,9 +63,7 @@ class Values(object):
# get value
def get_cached_value(self,
path,
index,
config_bag):
option_bag):
"""get value directly in cache if set
otherwise calculated value and set it in cache
@ -81,40 +79,36 @@ class Values(object):
:returns: value
"""
# try to retrive value in cache
setting_properties = config_bag.setting_properties
is_cached, value = self._p_.getcache(path,
setting_properties = option_bag.config_bag.setting_properties
is_cached, value = self._p_.getcache(option_bag.path,
expires_time,
index,
option_bag.index,
setting_properties,
config_bag.properties,
option_bag.properties,
'value')
if not is_cached:
# no cached value so get value
value = self.getvalue(path,
index,
config_bag)
value = self.getvalue(option_bag)
# validate value
context = self._getcontext()
opt = config_bag.option
opt = option_bag.option
opt.impl_validate(value,
option_bag,
context=context,
force_index=index,
check_error=True,
config_bag=config_bag)
check_error=True)
if setting_properties and 'warnings' in setting_properties:
opt.impl_validate(value,
option_bag,
context=context,
force_index=index,
check_error=False,
config_bag=config_bag)
check_error=False)
# store value in cache
if not is_cached:
self._p_.setcache(path,
index,
self._p_.setcache(option_bag.path,
option_bag.index,
value,
setting_properties,
config_bag.properties)
option_bag.properties)
if isinstance(value, list):
# return a copy, so value cannot be modified
return value.copy()
@ -122,9 +116,7 @@ class Values(object):
return value
def getvalue(self,
path,
index,
config_bag):
option_bag):
"""actually retrieves the value
:param path: the path of the `Option`
@ -134,37 +126,22 @@ class Values(object):
"""
# get owner and value from store
# index allowed only for slave
opt = config_bag.option
is_slave = opt.impl_is_master_slaves('slave')
index = option_bag.index
is_slave = option_bag.option.impl_is_master_slaves('slave')
if index is None or not is_slave:
_index = None
else:
_index = index
owner, value = self._p_.getowner(path,
owner, value = self._p_.getowner(option_bag.path,
owners.default,
index=_index,
with_value=True)
if owner != owners.default:
if config_bag.setting_properties is None:
# get property without apply requires
settings = self._getcontext().cfgimpl_get_settings()
self_properties = settings.getproperties(path,
index,
config_bag,
apply_requires=False)
else:
# if a value is store in storage, check if not frozen + force_default_on_freeze
# if frozen + force_default_on_freeze => force default value
self_properties = config_bag.properties
if self_properties is None:
settings = self._getcontext().cfgimpl_get_settings()
self_properties = settings.getproperties(path,
index,
config_bag)
config_bag.properties = self_properties
if not ('frozen' in self_properties and \
'force_default_on_freeze' in self_properties):
if not ('frozen' in option_bag.properties and \
'force_default_on_freeze' in option_bag.properties):
if index is not None and not is_slave:
if len(value) > index:
return value[index]
@ -172,14 +149,10 @@ class Values(object):
#so return default value
else:
return value
return self.getdefaultvalue(path,
index,
config_bag)
return self.getdefaultvalue(option_bag)
def getdefaultvalue(self,
path,
index,
config_bag):
option_bag):
"""get default value:
- get meta config value or
- get calculated value or
@ -192,36 +165,43 @@ class Values(object):
:returns: default value
"""
context = self._getcontext()
opt = config_bag.option
config_bag = option_bag.config_bag
opt = option_bag.option
index = option_bag.index
def _reset_cache(_value):
is_cache, cache_value = self._p_.getcache(path,
is_cache, cache_value = self._p_.getcache(option_bag.path,
expires_time,
index,
config_bag.setting_properties,
config_bag.properties,
option_bag.properties,
'value')
if is_cache and cache_value == _value:
# calculation return same value as previous value,
# so do not invalidate cache
return
# calculated value is a new value, so reset cache
context.cfgimpl_reset_cache(opt,
path,
config_bag)
context.cfgimpl_reset_cache(option_bag)
if opt.impl_is_master_slaves('slave'):
index_ = index
else:
index_ = None
if self._is_meta(path,
if option_bag.index != index_:
moption_bag = OptionBag()
moption_bag.set_option(opt,
option_bag.path,
index_,
config_bag):
config_bag)
moption_bag.fromconsistency = option_bag.fromconsistency.copy()
else:
moption_bag = option_bag
if self._is_meta(moption_bag):
meta = context.cfgimpl_get_meta()
# retrieved value from meta config
try:
value = meta.getattr(path,
index,
config_bag)
# FIXME could have different property!
value = meta.getattr(moption_bag.path,
moption_bag)
except PropertiesOptionError:
# if properties error, return an other default value
# unexpected error, should not happened
@ -237,7 +217,7 @@ class Values(object):
callback=callback,
callback_params=callback_params,
index=index,
config_bag=config_bag)
option_bag=option_bag)
if isinstance(value, list) and index is not None:
# if value is a list and index is set
if opt.impl_is_submulti() and (value == [] or not isinstance(value[0], list)):
@ -309,116 +289,94 @@ class Values(object):
# set value
def setvalue(self,
path,
index,
value,
config_bag,
option_bag,
_commit):
context = self._getcontext()
owner = context.cfgimpl_get_settings().getowner()
if config_bag.validate:
if index is not None or config_bag.option._has_consistencies(context):
if option_bag.config_bag.validate:
if option_bag.index is not None or option_bag.option._has_consistencies(context):
# set value to a fake config when option has dependency
# validation will be complet in this case (consistency, ...)
tested_context = context._gen_fake_values()
sconfig_bag = config_bag.copy()
sconfig_bag.validate = False
tested_context.cfgimpl_get_values().setvalue(path,
index,
value,
sconfig_bag,
#sconfig_bag = config_bag.copy()
ori_validate = option_bag.config_bag.validate
if ori_validate is True:
option_bag.config_bag.validate = False
try:
tested_context.cfgimpl_get_values().setvalue(value,
option_bag,
True)
sconfig_bag.validate = True
tested_context.getattr(path,
index,
sconfig_bag)
option_bag.config_bag.validate = True
tested_context.getattr(option_bag.path,
option_bag)
except Exception as exc:
if ori_validate is True:
option_bag.config_bag.validate = True
raise exc
else:
self.setvalue_validation(path,
index,
value,
config_bag)
self.setvalue_validation(value,
option_bag)
self._setvalue(path,
index,
self._setvalue(option_bag,
value,
owner,
config_bag,
commit=_commit)
def setvalue_validation(self,
path,
index,
value,
config_bag):
option_bag):
context = self._getcontext()
settings = context.cfgimpl_get_settings()
# First validate properties with this value
self_properties = config_bag.properties
if self_properties is None:
self_properties = settings.getproperties(path,
index,
config_bag)
config_bag.properties = self_properties
opt = config_bag.option
settings.validate_frozen(path,
index,
config_bag)
settings.validate_mandatory(path,
index,
value,
config_bag)
opt = option_bag.option
settings.validate_frozen(option_bag)
settings.validate_mandatory(value,
option_bag)
# Value must be valid for option
opt.impl_validate(value,
config_bag,
option_bag,
context,
check_error=True,
force_index=index)
if config_bag.setting_properties and 'warnings' in config_bag.setting_properties:
check_error=True)
if option_bag.config_bag.setting_properties and \
'warnings' in option_bag.config_bag.setting_properties:
# No error found so emit warnings
opt.impl_validate(value,
config_bag,
option_bag,
context,
check_error=False,
force_index=index)
check_error=False)
def _setvalue(self,
path,
index,
option_bag,
value,
owner,
config_bag,
commit=True):
self._getcontext().cfgimpl_reset_cache(config_bag.option,
path,
config_bag)
self._getcontext().cfgimpl_reset_cache(option_bag)
if isinstance(value, list):
# copy
value = list(value)
self._p_.setvalue(path,
value = value.copy()
self._p_.setvalue(option_bag.path,
value,
owner,
index,
option_bag.index,
commit)
def _is_meta(self,
path,
index,
config_bag,
option_bag,
force_owner_is_default=False):
if not force_owner_is_default and self._p_.hasvalue(path,
index=index):
if not force_owner_is_default and self._p_.hasvalue(option_bag.path,
index=option_bag.index):
# has already a value, so not meta
return False
context = self._getcontext()
meta = context.cfgimpl_get_meta()
if meta is None:
return False
opt = config_bag.option
opt = option_bag.option
if opt.impl_is_master_slaves('slave'):
master = opt.impl_get_master_slaves().getmaster()
masterp = master.impl_getpath(context)
@ -426,29 +384,23 @@ class Values(object):
if self._p_.hasvalue(masterp,
index=None):
return False
return not meta.cfgimpl_get_values().is_default_owner(path,
index,
config_bag)
return not meta.cfgimpl_get_values().is_default_owner(option_bag)
#______________________________________________________________________
# owner
def is_default_owner(self,
path,
index,
config_bag,
option_bag,
validate_meta=undefined):
return self._getowner(path,
index,
config_bag,
return self.getowner(option_bag,
validate_meta=validate_meta,
only_default=True) == owners.default
def getowner(self,
path,
index,
config_bag):
option_bag,
validate_meta=True,
only_default=False):
"""
retrieves the option's owner
@ -457,199 +409,144 @@ class Values(object):
was present
:returns: a `setting.owners.Owner` object
"""
return self._getowner(path,
index,
config_bag)
def _getowner(self,
path,
index,
config_bag,
validate_meta=True,
only_default=False):
"""get owner of an option
"""
context = self._getcontext()
opt = config_bag.option
opt = option_bag.option
if opt.impl_is_symlinkoption():
config_bag.ori_option = opt
option_bag.ori_option = opt
opt = opt.impl_getopt()
config_bag.option = opt
path = opt.impl_getpath(context)
self_properties = config_bag.properties
option_bag.option = opt
option_bag.path = opt.impl_getpath(context)
self_properties = option_bag.properties
settings = context.cfgimpl_get_settings()
if self_properties is None:
self_properties = settings.getproperties(path,
index,
config_bag)
config_bag.properties = self_properties
if config_bag.setting_properties is not None:
settings.validate_properties(path,
index,
config_bag)
if option_bag.config_bag.setting_properties is not None:
settings.validate_properties(option_bag)
if 'frozen' in self_properties and 'force_default_on_freeze' in self_properties:
return owners.default
if only_default:
if self._p_.hasvalue(path,
index):
if self._p_.hasvalue(option_bag.path,
option_bag.index):
owner = undefined
else:
owner = owners.default
else:
owner = self._p_.getowner(path,
owner = self._p_.getowner(option_bag.path,
owners.default,
index=index)
index=option_bag.index)
if owner is owners.default and validate_meta is not False:
meta = context.cfgimpl_get_meta()
if meta is not None and self._is_meta(path,
index,
config_bag):
owner = meta.cfgimpl_get_values()._getowner(path,
index,
config_bag,
if meta is not None and self._is_meta(option_bag):
owner = meta.cfgimpl_get_values().getowner(option_bag,
only_default=only_default)
return owner
def setowner(self,
path,
index,
owner,
config_bag):
option_bag):
"""
sets a owner to an option
:param opt: the `option.Option` object
:param owner: a valid owner, that is a `setting.owners.Owner` object
"""
opt = config_bag.option
opt = option_bag.option
if opt.impl_is_symlinkoption():
raise ConfigError(_("can't set owner for the symlinkoption \"{}\""
"").format(opt.impl_get_display_name()))
if owner in forbidden_owners:
raise ConfigError(_('set owner "{0}" is forbidden').format(str(owner)))
if not self._p_.hasvalue(path):
if not self._p_.hasvalue(option_bag.path):
raise ConfigError(_('no value for {0} cannot change owner to {1}'
'').format(path, owner))
self.setowner_validation(path,
index,
config_bag)
self._p_.setowner(path, owner, index=index)
'').format(option_bag.path, owner))
self._getcontext().cfgimpl_get_settings().validate_frozen(option_bag)
self._p_.setowner(option_bag.path,
owner,
index=option_bag.index)
#______________________________________________________________________
# reset
def reset(self,
path,
config_bag,
option_bag,
_commit=True):
context = self._getcontext()
setting = context.cfgimpl_get_settings()
hasvalue = self._p_.hasvalue(path)
hasvalue = self._p_.hasvalue(option_bag.path)
if hasvalue and config_bag.validate:
if hasvalue and option_bag.config_bag.validate:
ori_validate = option_bag.config_bag.validate
if ori_validate is True:
option_bag.config_bag.validate = False
fake_context = context._gen_fake_values()
fake_value = fake_context.cfgimpl_get_values()
sconfig_bag = config_bag.copy()
sconfig_bag.validate = False
fake_value.reset(path,
sconfig_bag)
value = fake_value.getdefaultvalue(path,
None,
config_bag)
fake_value.setvalue_validation(path,
None,
value,
config_bag)
opt = config_bag.option
fake_value.reset(option_bag)
if ori_validate is True:
option_bag.config_bag.validate = True
value = fake_value.getdefaultvalue(option_bag)
fake_value.setvalue_validation(value,
option_bag)
opt = option_bag.option
if opt.impl_is_master_slaves('master'):
opt.impl_get_master_slaves().reset(self,
config_bag,
option_bag,
_commit=_commit)
if hasvalue:
if 'force_store_value' in setting.getproperties(path,
None,
config_bag):
value = self.getdefaultvalue(path,
None,
config_bag)
self._setvalue(path,
None,
if 'force_store_value' in option_bag.properties:
value = self.getdefaultvalue(option_bag)
self._setvalue(option_bag,
value,
owners.forced,
config_bag,
commit=_commit)
else:
self._p_.resetvalue(path,
self._p_.resetvalue(option_bag.path,
_commit)
context.cfgimpl_reset_cache(config_bag.option,
path,
config_bag)
if not opt.impl_is_master_slaves('master'):
# if master, already reset behind
pass
context.cfgimpl_reset_cache(option_bag)
def reset_slave(self,
path,
index,
config_bag):
option_bag):
if self._p_.hasvalue(path, index=index):
if self._p_.hasvalue(option_bag.path, index=option_bag.index):
context = self._getcontext()
if config_bag.validate:
if option_bag.config_bag.validate:
fake_context = context._gen_fake_values()
fake_value = fake_context.cfgimpl_get_values()
sconfig_bag = config_bag.copy()
sconfig_bag.validate = False
fake_value.reset_slave(path,
index,
sconfig_bag)
value = fake_value.getdefaultvalue(path,
index,
config_bag)
fake_value.setvalue_validation(path,
index,
value,
config_bag)
self._p_.resetvalue_index(path, index)
context.cfgimpl_reset_cache(config_bag.option,
path,
config_bag)
ori_validate = option_bag.config_bag.validate
option_bag.config_bag.validate = False
try:
fake_value.reset_slave(option_bag)
value = fake_value.getdefaultvalue(option_bag)
fake_value.setvalue_validation(value,
option_bag)
option_bag.config_bag.validate = ori_validate
except Exception as err:
option_bag.config_bag.validate = ori_validate
raise err
self._p_.resetvalue_index(option_bag.path, option_bag.index)
context.cfgimpl_reset_cache(option_bag)
def reset_master(self,
subconfig,
path,
index,
config_bag):
option_bag,
subconfig):
current_value = self.get_cached_value(path,
None,
config_bag)
current_value = self.get_cached_value(option_bag)
length = len(current_value)
if index >= length:
raise IndexError(_('index "{}" is higher than the length "{}" '
'for option "{}"').format(index,
length,
config_bag.option.impl_get_display_name()))
option_bag.option.impl_get_display_name()))
current_value.pop(index)
self.setvalue(path,
None,
current_value,
config_bag,
self.setvalue(current_value,
option_bag,
_commit=True)
subconfig.cfgimpl_get_description().pop(self,
index,
config_bag)
def setowner_validation(self,
path,
index,
config_bag):
context = self._getcontext()
settings = context.cfgimpl_get_settings()
# First validate properties with this value
self_properties = config_bag.properties
settings.validate_frozen(path,
index,
config_bag)
option_bag)
#______________________________________________________________________
# information
@ -684,24 +581,26 @@ class Values(object):
settings = context.cfgimpl_get_settings()
# for option in config.cfgimpl_get_children(self.config_bag):
for option in description.impl_getchildren(config_bag, context):
sconfig_bag = config_bag.copy('nooption')
sconfig_bag.option = option
name = option.impl_getname()
path = '.'.join(currpath + [name])
if option.impl_is_optiondescription():
ori_setting_properties = sconfig_bag.setting_properties
sconfig_bag.setting_properties = od_setting_properties
ori_setting_properties = config_bag._setting_properties
config_bag._setting_properties = od_setting_properties
try:
subconfig = config.getattr(name,
option_bag = OptionBag()
option_bag.set_option(option,
path,
None,
sconfig_bag)
config_bag)
subconfig = config.getattr(name,
option_bag)
except PropertiesOptionError as err:
pass
else:
sconfig_bag.setting_properties = ori_setting_properties
config_bag._setting_properties = ori_setting_properties
for path in self._mandatory_warnings(context,
sconfig_bag,
config_bag,
option,
currpath + [name],
subconfig,
@ -711,26 +610,24 @@ class Values(object):
# don't verifying symlink
try:
if not option.impl_is_master_slaves('slave'):
self_properties = settings.getproperties(path,
option_bag = OptionBag()
option_bag.set_option(option,
path,
None,
sconfig_bag)
sconfig_bag.properties = self_properties
if 'mandatory' in self_properties or 'empty' in self_properties:
config_bag)
if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties:
config.getattr(name,
None,
sconfig_bag)
option_bag)
else:
for index in range(config.cfgimpl_get_length()):
self_properties = settings.getproperties(path,
option_bag = OptionBag()
option_bag.set_option(option,
path,
index,
sconfig_bag)
sconfig_bag.properties = self_properties
if 'mandatory' in self_properties:
config_bag)
if 'mandatory' in option_bag.properties:
config.getattr(name,
index,
sconfig_bag)
option_bag)
except PropertiesOptionError as err:
if err.proptype == ['mandatory']:
yield path
@ -750,7 +647,8 @@ class Values(object):
od_setting_properties = config_bag.setting_properties - {'mandatory', 'empty'}
setting_properties = set(config_bag.setting_properties) - {'warnings'}
setting_properties.update(['mandatory', 'empty'])
config_bag.setting_properties = frozenset(setting_properties)
config_bag = ConfigBag(config=config_bag.config)
config_bag._setting_properties = frozenset(setting_properties)
config_bag.force_permissive = True
descr = context.cfgimpl_get_description()