allow caching with the demoting_error_warning property

tests/test_cache.py

@@ -559,6 +559,8 @@ async def test_cache_global_properties():
 
 @pytest.mark.asyncio
 async def test_callback_value_incr():
+    global incr
+    incr = -1
     val1 = IntOption('val1', "", Calculation(return_incr), properties=('expire',))
     val2 = IntOption('val2', "", Calculation(calc_value, Params(ParamOption(val1))))
     od1 = OptionDescription('rootconfig', '', [val1, val2])
@@ -579,3 +581,30 @@ async def test_callback_value_incr():
         assert await cfg.option('val1').value.get() == 2
         assert await cfg.option('val2').value.get() == 2
     assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_callback_value_incr_demoting():
+    global incr
+    incr = -1
+    val1 = IntOption('val1', "", Calculation(return_incr), properties=('expire',))
+    val2 = IntOption('val2', "", Calculation(calc_value, Params(ParamOption(val1))))
+    od1 = OptionDescription('rootconfig', '', [val1, val2])
+    async with await Config(od1) as cfg:
+        await cfg.property.add('demoting_error_warning')
+        assert await cfg.cache.get_expiration_time() == 5
+        await cfg.cache.set_expiration_time(1)
+        assert await cfg.cache.get_expiration_time() == 1
+        await cfg.property.read_write()
+        assert await cfg.option('val1').value.get() == 1
+        sleep(1)
+        assert await cfg.option('val2').value.get() == 1
+        sleep(1)
+        assert await cfg.option('val1').value.get() == 1
+        assert await cfg.option('val2').value.get() == 1
+        sleep(2)
+        assert await cfg.option('val1').value.get() == 2
+        assert await cfg.option('val2').value.get() == 2
+        assert await cfg.option('val1').value.get() == 2
+        assert await cfg.option('val2').value.get() == 2
+    assert not await list_sessions()

tests/test_config_api.py

@@ -323,13 +323,10 @@ async def test_filename(config_type):
         await cfg.option('a').value.set('/tmp')
         await cfg.option('a').value.set('/tmp/')
         await cfg.option('a').value.set('/tmp/text.txt')
-        await cfg.option('a').value.set('tmp')
-        await cfg.option('a').value.set('tmp/')
-        await cfg.option('a').value.set('tmp/text.txt')
+        await cfg.option('a').value.set('/tmp/with space.txt')
+        await cfg.option('a').value.set('/tmp/with$.txt')
         with pytest.raises(ValueError):
-            await cfg.option('a').value.set('/tmp/with space.txt')
-        with pytest.raises(ValueError):
-            await cfg.option('a').value.set('/tmp/with$.txt')
+            await cfg.option('a').value.set('not starts with /')
     assert not await list_sessions()
 
 

tests/test_dyn_optiondescription.py

@@ -642,6 +642,73 @@ async def test_dyndescription_root():
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_dyndescription_disable_suffix_root():
+    boolean = BoolOption('boolean', '', True)
+    disabled_property = Calculation(calc_value,
+                                    Params(ParamValue('disabled'),
+                                           kwargs={'condition': ParamOption(boolean),
+                                                   'expected': ParamValue(False),
+                                                   'default': ParamValue(None)}))
+    val = StrOption('val', '', ['ext1', 'ext2'], properties=(disabled_property,), multi=True)
+    st1 = StrOption('st', '')
+    dod = DynOptionDescription('dod', '', [st1], suffixes=Calculation(calc_value, Params(ParamOption(val, notraisepropertyerror=True))), properties=(disabled_property,))
+    od = OptionDescription('root', 'root', [boolean, val, dod])
+    config = await Config(od, session_id='test')
+    await config.property.read_write()
+    assert await config.value.dict() == {'boolean': True, 'val': ['ext1', 'ext2'], 'dodext1.stext1': None, 'dodext2.stext2': None}
+    #
+    await config.option('boolean').value.set(False)
+    assert await config.value.dict() == {'boolean': False}
+    await delete_session('test')
+    assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_dyndescription_disable_suffix_root_2():
+    boolean = BoolOption('boolean', '', False)
+    disabled_property = Calculation(calc_value,
+                                    Params(ParamValue('disabled'),
+                                           kwargs={'condition': ParamOption(boolean),
+                                                   'expected': ParamValue(False),
+                                                   'default': ParamValue(None)}))
+    val = StrOption('val', '', ['ext1', 'ext2'], properties=(disabled_property,), multi=True)
+    st1 = StrOption('st', '')
+    dod = DynOptionDescription('dod', '', [st1], suffixes=Calculation(calc_value, Params(ParamOption(val, notraisepropertyerror=True))), properties=(disabled_property,))
+    od = OptionDescription('root', 'root', [boolean, val, dod])
+    config = await Config(od, session_id='test')
+    await config.property.read_write()
+    assert await config.value.dict() == {'boolean': False}
+    #
+    await config.option('boolean').value.set(True)
+    assert await config.value.dict() == {'boolean': True, 'val': ['ext1', 'ext2'], 'dodext1.stext1': None, 'dodext2.stext2': None}
+    await delete_session('test')
+    assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_dyndescription_disable_suffix():
+    boolean = BoolOption('boolean', '', True)
+    disabled_property = Calculation(calc_value,
+                                    Params(ParamValue('disabled'),
+                                           kwargs={'condition': ParamOption(boolean),
+                                                   'expected': ParamValue(False),
+                                                   'default': ParamValue(None)}))
+    val = StrOption('val', '', ['ext1', 'ext2'], properties=(disabled_property,), multi=True)
+    st1 = StrOption('st', '')
+    dod = DynOptionDescription('dod', '', [st1], suffixes=Calculation(calc_value, Params(ParamOption(val, notraisepropertyerror=True))), properties=(disabled_property,))
+    od = OptionDescription('root', 'root', [boolean, val, dod])
+    od2 = OptionDescription('root', 'root', [od])
+    config = await Config(od2, session_id='test')
+    await config.property.read_write()
+    assert await config.value.dict() == {'root.boolean': True, 'root.val': ['ext1', 'ext2'], 'root.dodext1.stext1': None, 'root.dodext2.stext2': None}
+    #
+    await config.option('root.boolean').value.set(False)
+    assert await config.value.dict() == {'root.boolean': False}
+    await delete_session('test')
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_requires_dyndescription():
     boolean = BoolOption('boolean', '', True)

tests/test_leadership.py

@@ -298,6 +298,32 @@ async def test_groups_with_leader_make_dict(config_type):
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_groups_with_leader_make_dict2(config_type):
+    ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
+    netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
+    interface1 = Leadership('other', '', [ip_admin_eth0, netmask_admin_eth0])
+    od = OptionDescription('root', '', [interface1])
+    async with await Config(od) as cfg:
+        cfg = await get_config(cfg, config_type)
+        assert await cfg.value.dict() == {'other.ip_admin_eth0': [], 'other.netmask_admin_eth0': []}
+        assert await cfg.value.dict(leader_to_list=True) == {'other.ip_admin_eth0': []}
+        if config_type != 'tiramisu-api':
+            # FIXME useful? already in leadership
+            assert await cfg.option('other.ip_admin_eth0').value.len() == 0
+            assert await cfg.option('other.netmask_admin_eth0').value.len() == 0
+        await cfg.option('other.ip_admin_eth0').value.set(['ip1', 'ip2'])
+        if config_type != 'tiramisu-api':
+            # FIXME
+            assert await cfg.option('other.ip_admin_eth0').value.len() == 2
+            assert await cfg.option('other.netmask_admin_eth0').value.len() == 2
+        assert await cfg.value.dict() == {'other.ip_admin_eth0': ['ip1', 'ip2'], 'other.netmask_admin_eth0': [None, None]}
+        assert await cfg.value.dict(leader_to_list=True) == {'other.ip_admin_eth0': [{'other.ip_admin_eth0': 'ip1', 'other.netmask_admin_eth0': None}, {'other.ip_admin_eth0': 'ip2', 'other.netmask_admin_eth0': None}]}
+        if config_type == 'tiramisu-api':
+            await cfg.send()
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_groups_with_leader_default_value(config_type):
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
@@ -362,7 +388,28 @@ async def test_groups_with_leader_hidden_in_config():
             await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
         with pytest.raises(PropertiesOptionError):
             await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
-        await cfg.value.dict(leader_to_list=True) == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.1'}]}
+        assert await cfg.value.dict() == {}
+        assert await cfg.value.dict(leader_to_list=True) == {}
+    assert not await list_sessions()
+
+
+async def test_groups_with_leader_hidden_in_config2():
+    ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
+    netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=('hidden',))
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    od = OptionDescription('root', '', [interface1])
+    async with await Config(od) as cfg:
+        await cfg.property.read_write()
+        await cfg.permissive.add('hidden')
+        assert await cfg.forcepermissive.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
+        await cfg.forcepermissive.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1'])
+        assert await cfg.forcepermissive.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
+        with pytest.raises(PropertiesOptionError):
+            await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
+        with pytest.raises(PropertiesOptionError):
+            await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
+        assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.1']}
+        assert await cfg.value.dict(leader_to_list=True) == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.1'}]}
     assert not await list_sessions()
 
 
@@ -735,6 +782,19 @@ async def test_values_with_leader_and_followers_leader_pop():
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_follower_unique():
+    ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
+    netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=('unique',))
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    maconfig = OptionDescription('toto', '', [interface1])
+    async with await Config(maconfig) as cfg:
+        await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.146"])
+        # unique property is removed for a follower
+        assert not await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).property.get()
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_values_with_leader_owner(config_type):
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
@@ -976,3 +1036,28 @@ async def test_follower_force_store_value_reset():
         await cfg.option('od.interface0.ip_admin_eth0').value.reset()
         assert not await cfg.option('od.interface0.netmask_admin_eth0', 0).owner.isdefault()
     assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_follower_properties():
+    ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
+    netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=('aproperty',))
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    maconfig = OptionDescription('toto', '', [interface1])
+    async with await Config(maconfig) as cfg:
+        await cfg.property.read_write()
+        await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['1.1.1.1', '192.168.0.0'])
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0').property.get() == ('aproperty',)
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).property.get() == ('aproperty',)
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).property.get() == ('aproperty',)
+        #
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).property.add('newproperty')
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0').property.get() == ('aproperty',)
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).property.get() == ('aproperty', 'newproperty')
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).property.get() == ('aproperty',)
+        #
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0').property.add('newproperty1')
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0').property.get() == ('aproperty', 'newproperty1')
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).property.get() == ('aproperty', 'newproperty', 'newproperty1')
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).property.get() == ('aproperty', 'newproperty1')
+    assert not await list_sessions()

tests/test_option_callback.py

@@ -10,7 +10,7 @@ from tiramisu.setting import groups, owners
 from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
     StrOption, OptionDescription, SymLinkOption, IPOption, NetmaskOption, Leadership, \
     undefined, Calculation, Params, ParamOption, ParamValue, ParamIndex, calc_value, \
-    valid_ip_netmask, ParamSelfOption, ParamInformation
+    valid_ip_netmask, ParamSelfOption, ParamInformation, ParamSelfInformation
 from tiramisu.error import PropertiesOptionError, ConflictError, LeadershipError, ConfigError
 from tiramisu.i18n import _
 from tiramisu.storage import list_sessions
@@ -378,6 +378,28 @@ async def test_callback_information(config_type):
         await cfg.information.set('information', 'new_value')
         assert await cfg.option('val1').value.get() == 'new_value'
         assert await cfg.option('val2').value.get() == 'new_value'
+        await cfg.information.set('information', 'new_value2')
+        assert await cfg.option('val1').value.get() == 'new_value2'
+        assert await cfg.option('val2').value.get() == 'new_value2'
+    assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_callback_information2(config_type):
+    val1 = StrOption('val1', "", Calculation(return_value, Params(ParamSelfInformation('information', 'no_value'))))
+    val2 = StrOption('val2', "", Calculation(return_value, Params(ParamSelfInformation('information'))))
+    val2.impl_set_information('information', 'new_value')
+    val3 = StrOption('val3', "", Calculation(return_value, Params(ParamSelfInformation('information'))))
+    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3])
+    async with await Config(maconfig) as cfg:
+        await cfg.property.read_write()
+        cfg = await get_config(cfg, config_type)
+        assert await cfg.option('val1').value.get() == 'no_value'
+        assert await cfg.option('val2').value.get() == 'new_value'
+        with pytest.raises(ConfigError):
+            await cfg.option('val3').value.get()
+        await cfg.option('val2').information.set('information', 'new_value2')
+        assert await cfg.option('val2').value.get() == 'new_value2'
     assert not await list_sessions()
 
 
@@ -1276,6 +1298,21 @@ async def test_callback_calculating_invalid():
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_callback_unrestraint():
+    opt1 = IntOption('opt1', '', 1)
+    opt2 = IntOption('opt2', '', Calculation(return_value, Params(ParamOption(opt1))))
+    od1 = OptionDescription('od1', '', [opt1], properties=('disabled',))
+    od2 = OptionDescription('od2', '', [opt2])
+    maconfig = OptionDescription('rootconfig', '', [od1, od2])
+    async with await Config(maconfig) as cfg:
+        await cfg.property.read_write()
+        with pytest.raises(ConfigError):
+            await cfg.option('od2.opt2').value.get()
+        assert await cfg.unrestraint.option('od2.opt2').value.get() == 1
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_callback_calculating_disabled():
     opt1 = BoolOption('opt1', '', properties=('disabled',))

tests/test_option_setting.py

@@ -191,9 +191,9 @@ async def test_property_get_unique_empty():
     async with await Config(descr) as cfg:
         await cfg.property.read_write()
         assert await cfg.option('string').property.get() == {'empty', 'unique'}
-        assert await cfg.option('string2').property.get() == {'empty'}
-        assert await cfg.option('string3').property.get() == {'unique'}
-        assert await cfg.option('string4').property.get() == set()
+        assert await cfg.option('string2').property.get() == {'empty', 'notunique'}
+        assert await cfg.option('string3').property.get() == {'unique', 'notempty'}
+        assert await cfg.option('string4').property.get() == {'notunique', 'notempty'}
     assert not await list_sessions()
 
 

tests/test_requires.py

@@ -1070,6 +1070,38 @@ async def test_requires_different_inverse_unicode(config_type):
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_requires_different_inverse_unicode2(config_type):
+    a = BoolOption('activate_service', '', False)
+    d = StrOption('activate_other_service', '', 'val2')
+    disabled_property = Calculation(calc_value,
+                                    Params(ParamValue('disabled'),
+                                           kwargs={'condition_0': ParamOption(a),
+                                                   'condition_1': ParamOption(d),
+                                                   'expected_0': ParamValue(True),
+                                                   'expected_1': ParamValue(['val2', 'val3']),
+                                                   'condition_operator': ParamValue('OR'),
+                                                   'reverse_condition_1': ParamValue(True)}))
+    b = IPOption('ip_address_service', '', properties=(disabled_property,))
+    od = OptionDescription('service', '', [a, d, b])
+    async with await Config(od) as cfg:
+        await cfg.property.read_write()
+        cfg = await get_config(cfg, config_type)
+        assert await cfg.option('ip_address_service').value.get() == None
+        await cfg.option('activate_service').value.set(True)
+        with pytest.raises(PropertiesOptionError):
+            await cfg.option('ip_address_service').value.get()
+        await cfg.option('activate_service').value.set(False)
+        assert await cfg.option('ip_address_service').value.get() == None
+        await cfg.option('activate_other_service').value.set('val1')
+        with pytest.raises(PropertiesOptionError):
+            await cfg.option('ip_address_service').value.get()
+        await cfg.option('activate_service').value.set(True)
+        with pytest.raises(PropertiesOptionError):
+            await cfg.option('ip_address_service').value.get()
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_optiondescription_requires():
     a = BoolOption('activate_service', '', True)

tiramisu/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2012-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -18,7 +18,7 @@ from .function import calc_value, calc_value_property_help, valid_ip_netmask, \
                       valid_network_netmask, valid_in_network, valid_broadcast, \
                       valid_not_equal
 from .autolib import Calculation, Params, ParamOption, ParamDynOption, ParamSelfOption, \
-                     ParamValue, ParamIndex, ParamSuffix, ParamInformation
+                     ParamValue, ParamIndex, ParamSuffix, ParamInformation, ParamSelfInformation
 from .option import *
 from .error import APIError
 from .api import Config, MetaConfig, GroupConfig, MixConfig
@@ -37,6 +37,7 @@ allfuncs = ['Calculation',
             'ParamIndex',
             'ParamSuffix',
             'ParamInformation',
+            'ParamSelfInformation',
             'MetaConfig',
             'MixConfig',
             'GroupConfig',

tiramisu/api.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -464,24 +464,23 @@ class TiramisuOptionInformation(CommonTiramisuOption):
     @option_and_connection
     async def get(self, key, default=undefined):
         """Get information"""
-        path = self._option_bag.path
         values = self._option_bag.config_bag.context.cfgimpl_get_values()
-        try:
-            return await values.get_information(self._option_bag.config_bag.connection,
-                                                key,
-                                                path=path)
-        except ValueError:
-            return self._option_bag.option.impl_get_information(key, default)
+        return await values.get_information(self._option_bag.config_bag,
+                                            self._option_bag,
+                                            key,
+                                            default,
+                                            )
 
     @option_and_connection
     async def set(self, key, value):
         """Set information"""
         path = self._option_bag.path
         values = self._option_bag.config_bag.context.cfgimpl_get_values()
-        await values.set_information(self._option_bag.config_bag.connection,
+        await values.set_information(self._option_bag.config_bag,
+                                     self._option_bag,
                                      key,
                                      value,
-                                     path=path)
+                                     )
 
     @option_and_connection
     async def reset(self,
@@ -890,10 +889,12 @@ class TiramisuContextInformation(TiramisuConfig):
                   default=undefined,
                   ):
         """Get an information"""
-        return await self._config_bag.context.impl_get_information(self._config_bag.connection,
-                                                                   name,
-                                                                   default,
-                                                                   )
+        values = self._config_bag.context.cfgimpl_get_values()
+        return await values.get_information(self._config_bag,
+                                            None,
+                                            name,
+                                            default,
+                                            )
 
     @connection
     async def set(self,

tiramisu/asyncinit.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2019-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2019-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/autolib.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2012-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -128,6 +128,10 @@ class ParamInformation(Param):
         self.default_value = default_value
 
 
+class ParamSelfInformation(ParamInformation):
+    __slots__ = tuple()
+
+
 class ParamIndex(Param):
     __slots__ = tuple()
 
@@ -166,8 +170,9 @@ class Calculation:
                 option_bag: OptionBag,
                 leadership_must_have_index: bool=False,
                 orig_value: Any=undefined,
-                allow_value_error=False,
-                force_value_warning=False,
+                allow_value_error: bool=False,
+                force_value_warning: bool=False,
+                for_settings: bool=False,
                 ) -> Any:
         return await carry_out_calculation(option_bag.option,
                                            callback=self.function,
@@ -178,20 +183,27 @@ class Calculation:
                                            orig_value=orig_value,
                                            allow_value_error=allow_value_error,
                                            force_value_warning=force_value_warning,
+                                           for_settings=for_settings,
                                            )
 
     async def help(self,
                    option_bag: OptionBag,
-                   leadership_must_have_index: bool=False) -> str:
+                   leadership_must_have_index: bool=False,
+                   for_settings: bool=False,
+                   ) -> str:
         if not self.help_function:
             return await self.execute(option_bag,
-                                      leadership_must_have_index=leadership_must_have_index)
+                                      leadership_must_have_index=leadership_must_have_index,
+                                      for_settings=for_settings,
+                                      )
         return await carry_out_calculation(option_bag.option,
                                            callback=self.help_function,
                                            callback_params=self.params,
                                            index=option_bag.index,
                                            config_bag=option_bag.config_bag,
-                                           leadership_must_have_index=leadership_must_have_index)
+                                           leadership_must_have_index=leadership_must_have_index,
+                                           for_settings=for_settings,
+                                           )
 
     def has_index(self, current_option):
         if hasattr(self, '_has_index'):
@@ -214,7 +226,9 @@ async def manager_callback(callbk: Param,
                            index: Optional[int],
                            orig_value,
                            config_bag: ConfigBag,
-                           leadership_must_have_index: bool) -> Any:
+                           leadership_must_have_index: bool,
+                           for_settings: bool,
+                           ) -> Any:
     """replace Param by true value"""
     def calc_index(callbk, index, same_leadership):
         if index is not None:
@@ -276,9 +290,11 @@ async def manager_callback(callbk: Param,
                              self_calc):
         # don't validate if option is option that we tried to validate
         config_bag = config_bag.copy()
-        config_bag.properties = config_bag.true_properties - {'warnings'}
+        if for_settings:
+            config_bag.properties = config_bag.true_properties - {'warnings'}
         config_bag.set_permissive()
-        #config_bag.properties -= {'warnings'}
+        if not for_settings:
+            config_bag.properties -= {'warnings'}
         option_bag = OptionBag()
         option_bag.set_option(opt,
                               index_,
@@ -297,8 +313,17 @@ async def manager_callback(callbk: Param,
         return callbk.value
 
     if isinstance(callbk, ParamInformation):
+        if isinstance(callbk, ParamSelfInformation):
+            option_bag = OptionBag()
+            option_bag.set_option(option,
+                                  index,
+                                  config_bag,
+                                  )
+        else:
+            option_bag = None
         try:
-            return await config_bag.context.impl_get_information(config_bag.connection,
+            return await config_bag.context.impl_get_information(config_bag,
+                                                                 option_bag,
                                                                  callbk.information_name,
                                                                  callbk.default_value,
                                                                  )
@@ -388,6 +413,7 @@ async def carry_out_calculation(option,
                                 leadership_must_have_index: bool=False,
                                 allow_value_error: bool=False,
                                 force_value_warning: bool=False,
+                                for_settings: bool=False,
                                 ):
     """a function that carries out a calculation for an option's value
 
@@ -417,7 +443,9 @@ async def carry_out_calculation(option,
                                                index,
                                                orig_value,
                                                config_bag,
-                                               leadership_must_have_index)
+                                               leadership_must_have_index,
+                                               for_settings,
+                                               )
                 if value is undefined:
                     return undefined
                 if key is None:
@@ -501,5 +529,4 @@ async def calculate(option,
                 '').format(str(error),
                            callback.__name__,
                            option.impl_get_display_name())
-    del error
-    raise ConfigError(msg)
+    raise ConfigError(msg) from error

tiramisu/config.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2012-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2012-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -111,19 +111,12 @@ class SubConfig:
         for woption in option_bag.option._get_dependencies(self.cfgimpl_get_description()):
             option = woption()
             if option.impl_is_dynoptiondescription():
-                subpath = option.impl_getpath().rsplit('.', 1)[0]
+                path = option.impl_getpath()
+                if '.' in path:
+                    subpath = option.impl_getpath().rsplit('.', 1)[0]
+                else:
+                    subpath = ''
                 for suffix in await option.get_suffixes(option_bag.config_bag):
-                    doption = option.to_dynoption(subpath,
-                                                  suffix,
-                                                  option)
-                    doption_bag = OptionBag()
-                    doption_bag.set_option(doption,
-                                           option_bag.index,
-                                           option_bag.config_bag)
-                    doption_bag.properties = await self.cfgimpl_get_settings().getproperties(doption_bag)
-                    await self.reset_one_option_cache(desc,
-                                                      resetted_opts,
-                                                      doption_bag)
                     async for coption in self.cfgimpl_get_description().get_children_recursively(None,
                                                                                                  None,
                                                                                                  option_bag.config_bag):
@@ -131,11 +124,20 @@ class SubConfig:
                         coption_bag.set_option(coption,
                                                option_bag.index,
                                                option_bag.config_bag)
-                        coption_bag.properties = await self.cfgimpl_get_settings().getproperties(coption_bag)
                         await self.reset_one_option_cache(option,
                                                           resetted_opts,
                                                           coption_bag,
                                                           )
+                    doption = option.to_dynoption(subpath,
+                                                  suffix,
+                                                  option)
+                    doption_bag = OptionBag()
+                    doption_bag.set_option(doption,
+                                           option_bag.index,
+                                           option_bag.config_bag)
+                    await self.reset_one_option_cache(desc,
+                                                      resetted_opts,
+                                                      doption_bag)
             elif option.issubdyn():
                 # it's an option in dynoptiondescription, remove cache for all generated option
                 dynopt = option.getsubdyn()
@@ -151,7 +153,7 @@ class SubConfig:
                     doption_bag.set_option(doption,
                                            option_bag.index,
                                            option_bag.config_bag)
-                    doption_bag.properties = await self.cfgimpl_get_settings().getproperties(doption_bag)
+                    #doption_bag.properties = await self.cfgimpl_get_settings().getproperties(doption_bag)
                     await self.reset_one_option_cache(desc,
                                                       resetted_opts,
                                                       doption_bag)
@@ -180,9 +182,16 @@ class SubConfig:
         context = self.cfgimpl_get_context()
         desc = context.cfgimpl_get_description()
         if option_bag is not None:
+            if 'cache' in option_bag.config_bag.properties:
+                has_cache = True
+                option_bag.config_bag.properties = option_bag.config_bag.properties - {'cache'}
+            else:
+                has_cache = False
             await self.reset_one_option_cache(desc,
                                               resetted_opts,
                                               option_bag)
+            if has_cache:
+                option_bag.config_bag.properties = option_bag.config_bag.properties | {'cache'}
         else:
             context._impl_values_cache.reset_all_cache()
             context._impl_properties_cache.reset_all_cache()
@@ -421,7 +430,8 @@ class SubConfig:
                               flatten,
                               fullpath,
                               pathsvalues,
-                              leader_to_list)
+                              leader_to_list,
+                              )
         return pathsvalues
 
     async def _make_dict(self,
@@ -434,6 +444,18 @@ class SubConfig:
         for opt in await self.cfgimpl_get_description().get_children(config_bag):
             if leader_to_list and opt.impl_is_optiondescription() and opt.impl_is_leadership():
                 # leader
+                try:
+                    loption_bag = OptionBag()
+                    loption_bag.set_option(opt,
+                                           None,
+                                           config_bag)
+                    loption_bag.properties = await self.cfgimpl_get_settings().getproperties(loption_bag)
+                    await self.cfgimpl_get_settings().validate_properties(loption_bag,
+                                                                          need_help=False)
+                except PropertiesOptionError as err:
+                    if err.proptype in (['mandatory'], ['empty']):
+                        raise err
+                    continue
                 children = await opt.get_children(config_bag)
                 leader = children[0]
                 loption_bag = OptionBag()
@@ -442,7 +464,7 @@ class SubConfig:
                                        config_bag)
                 loption_bag.properties = await self.cfgimpl_get_settings().getproperties(loption_bag)
                 leader_pathsvalues = {}
-                leader_currpath = _currpath + [leader.impl_getname()]
+                leader_currpath = _currpath + [opt.impl_getname()]
                 await self._make_sub_dict(leader_pathsvalues,
                                           leader_currpath,
                                           loption_bag,
@@ -571,7 +593,8 @@ class _CommonConfig(SubConfig):
         :param key: information's key (ex: "help", "doc"
         :param value: information's value (ex: "the help string")
         """
-        await self._impl_values.set_information(config_bag.connection,
+        await self._impl_values.set_information(config_bag,
+                                                None,
                                                 key,
                                                 value)
         for option in config_bag.context.cfgimpl_get_description()._cache_dependencies_information.get(key, []):
@@ -582,14 +605,17 @@ class _CommonConfig(SubConfig):
             await config_bag.context.cfgimpl_reset_cache(option_bag)
 
     async def impl_get_information(self,
-                                   connection,
+                                   config_bag,
+                                   option_bag,
                                    key,
-                                   default=undefined):
+                                   default,
+                                   ):
         """retrieves one information's item
 
         :param key: the item string (ex: "help")
         """
-        return await self._impl_values.get_information(connection,
+        return await self._impl_values.get_information(config_bag,
+                                                       option_bag,
                                                        key,
                                                        default)
 
@@ -1267,8 +1293,9 @@ class KernelMixConfig(KernelGroupConfig):
                          apiconfig):
         config = apiconfig._config_bag.context
         if config.impl_getname() in [child.impl_getname() for child in self._impl_children]:
-            raise ConflictError(_('config name must be uniq in '
-                                  'groupconfig for {0}').format(config.impl_getname()))
+            raise ConflictError(_('config name "{0}" is not uniq in '
+                                  'groupconfig "{1}"').format(config.impl_getname(),
+                                                              self.impl_getname()))
 
         config.parents.append(weakref.ref(self))
         self._impl_children.append(config)

tiramisu/error.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2012-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2012-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -20,6 +20,8 @@ from .i18n import _
 
 
 def display_list(lst, separator='and', add_quote=False):
+    if not lst:
+        return '""'
     if separator == 'and':
         separator = _('and')
     elif separator == 'or':

tiramisu/function.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2018-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -400,7 +400,10 @@ class CalcValue:
             for idx, calculated_condition in calculated_conditions.items():
                 if isinstance(calculated_expected, dict):
                     if idx is not None:
-                        current_matches = calculated_condition == calculated_expected[idx]
+                        if isinstance(calculated_expected[idx], list):
+                            current_matches = calculated_condition in calculated_expected[idx]
+                        else:
+                            current_matches = calculated_condition == calculated_expected[idx]
                     else:
                         current_matches = calculated_condition in calculated_expected.values()
                 else:

tiramisu/i18n.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-# Copyright (C) 2012-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2012-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/log.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "logger for tiramisu"
-# Copyright (C) 2019-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2019-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/baseoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2014-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2014-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -29,7 +29,7 @@ from ..i18n import _
 from ..setting import undefined, Settings
 from ..value import Values
 from ..error import ConfigError, display_list
-from ..autolib import Calculation, Params, ParamOption, ParamIndex
+from ..autolib import Calculation, Params, ParamOption
 
 STATIC_TUPLE = frozenset()
 
@@ -72,13 +72,9 @@ class Base:
         if is_multi:
             # if option is a multi, it cannot be 'empty' (None not allowed in the list) and cannot have multiple time the same value
             # 'empty' and 'unique' are removed for follower's option
-            if 'notunique' in properties:
-                properties = properties - {'notunique'}
-            else:
+            if 'notunique' not in properties:
                 properties = properties | {'unique'}
-            if 'notempty' in properties:
-                properties = properties - {'notempty'}
-            else:
+            if 'notempty' not in properties:
                 properties = properties | {'empty'}
         assert isinstance(properties, frozenset), _('invalid properties type {0} for {1},'
                                                     ' must be a frozenset').format(type(properties),

tiramisu/option/booloption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/broadcastoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/choiceoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -60,8 +60,8 @@ class ChoiceOption(Option):
         if isinstance(self._choice_values, Calculation):
             values = await self._choice_values.execute(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()))
+                raise ConfigError(_('the calculated values "{0}" for "{1}" is not a list'
+                                    '').format(values, self.impl_getname()))
         else:
             values = self._choice_values
         return values

tiramisu/option/dateoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/domainnameoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/dynoptiondescription.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -80,6 +80,8 @@ class DynOptionDescription(OptionDescription):
                               None,
                               config_bag)
         values = await self._suffixes.execute(option_bag)
+        if values is None:
+            values = []
         if __debug__:
             if not isinstance(values, list):
                 raise ValueError(_('DynOptionDescription suffixes for option "{}", is not a list ({})'

tiramisu/option/emailoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/filenameoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -21,11 +21,17 @@
 import re
 
 from ..i18n import _
-from .stroption import RegexpOption
+from .stroption import StrOption
 
 
-class FilenameOption(RegexpOption):
+class FilenameOption(StrOption):
     __slots__ = tuple()
-    _regexp = re.compile(r"^[a-zA-Z0-9\-\._~/+]+$")
     _type = 'filename'
     _display_name = _('file name')
+
+    def validate(self,
+                 value: str,
+                 ) -> None:
+        super().validate(value)
+        if not value.startswith('/'):
+            raise ValueError(_('must starts with "/"'))

tiramisu/option/floatoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/intoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/ipoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/leadership.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "Leadership support"
-# Copyright (C) 2014-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2014-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -69,11 +69,21 @@ class Leadership(OptionDescription):
                                                   child.impl_get_display_name()))
                 if idx != 0:
                     default = child.impl_getdefault()
-                    if default != [] and not isinstance(default, Calculation):
-                        raise ValueError(_('not allowed default value for follower option "{0}" '
-                                           'in leadership "{1}"'
-                                           '').format(child.impl_get_display_name(),
-                                                      self.impl_get_display_name()))
+                    if default != []:
+                        if child.impl_is_submulti() and isinstance(default, tuple):
+                            for val in default:
+                                if not isinstance(val, Calculation):
+                                    calculation = False
+                            else:
+                                # empty default is valid
+                                calculation = True
+                        else:
+                            calculation = isinstance(default, Calculation)
+                        if not calculation:
+                            raise ValueError(_('not allowed default value for follower option "{0}" '
+                                               'in leadership "{1}"'
+                                               '').format(child.impl_get_display_name(),
+                                                          self.impl_get_display_name()))
             if idx != 0:
                 # remove empty property for follower
                 child._properties = frozenset(child._properties - {'empty', 'unique'})

tiramisu/option/macoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2020-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/netmaskoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/networkoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/option.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "option types and option description"
-# Copyright (C) 2012-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2012-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -27,7 +27,7 @@ from itertools import chain
 from .baseoption import BaseOption, submulti, STATIC_TUPLE
 from ..i18n import _
 from ..setting import undefined, OptionBag, Undefined
-from ..autolib import Calculation, Params, ParamOption, ParamInformation
+from ..autolib import Calculation, Params, ParamOption, ParamInformation, ParamSelfInformation
 from ..error import (ConfigError, ValueWarning, ValueErrorWarning, PropertiesOptionError,
                      ValueOptionError, display_list)
 from .syndynoption import SynDynOption
@@ -67,7 +67,7 @@ class Option(BaseOption):
                  warnings_only: bool=False,
                  extra: Optional[Dict]=None):
         _setattr = object.__setattr__
-        _dependencies_information = []
+        _dependencies_information = [[], []]
         if not multi and default_multi is not None:
             raise ValueError(_("default_multi is set whereas multi is False"
                                " in option: {0}").format(name))
@@ -107,8 +107,10 @@ class Option(BaseOption):
                     if isinstance(param, ParamOption):
                         param.option._add_dependency(self)
                         self._has_dependency = True
+                    elif isinstance(param, ParamSelfInformation):
+                        _dependencies_information[1].append(param.information_name)
                     elif isinstance(param, ParamInformation):
-                        _dependencies_information.append(param.information_name)
+                        _dependencies_information[0].append(param.information_name)
 
                 self._validators = tuple(validators)
         if extra is not None and extra != {}:
@@ -165,7 +167,7 @@ class Option(BaseOption):
             if is_multi and isinstance(default, list):
                 default = tuple(default)
             _setattr(self, '_default', default)
-        if _dependencies_information:
+        if _dependencies_information[0] or _dependencies_information[1]:
             self._dependencies_information = _dependencies_information
 
     def value_dependencies(self,
@@ -188,8 +190,10 @@ class Option(BaseOption):
         for param in chain(value.params.args, value.params.kwargs.values()):
             if isinstance(param, ParamOption):
                 param.option._add_dependency(self)
+            elif isinstance(param, ParamSelfInformation):
+                _dependencies_information[1].append(param.information_name)
             elif isinstance(param, ParamInformation):
-                _dependencies_information.append(param.information_name)
+                _dependencies_information[0].append(param.information_name)
 
     #__________________________________________________________________________
     # option's information
@@ -203,8 +207,14 @@ class Option(BaseOption):
     def impl_is_dynsymlinkoption(self) -> bool:
         return False
 
-    def get_dependencies_information(self) -> List[str]:
-        return getattr(self, '_dependencies_information', [])
+    def get_dependencies_information(self,
+                                     itself=False,
+                                     ) -> List[str]:
+        if itself:
+            idx = 1
+        else:
+            idx = 0
+        return getattr(self, '_dependencies_information', [[], []])[idx]
 
     def get_type(self) -> str:
         # _display_name for compatibility with older version than 3.0rc3
@@ -323,7 +333,8 @@ class Option(BaseOption):
                             value: Any,
                             option_bag: OptionBag,
                             check_error: bool=True) -> None:
-        """
+        """Return True if value is really valid
+        If not validate or invalid return it returns False
         """
         config_bag = option_bag.config_bag
         force_index = option_bag.index
@@ -331,7 +342,7 @@ class Option(BaseOption):
 
         if check_error and config_bag is not undefined and \
                 not 'validator' in config_bag.properties:
-            return
+            return False
 
 
         def _is_not_unique(value, option_bag):
@@ -380,7 +391,7 @@ class Option(BaseOption):
                 raise ValueError(_('which must not be a list').format(_value,
                                                                       self.impl_get_display_name()))
             if isinstance(_value, Calculation) and config_bag is undefined:
-                return
+                return False
             if _value is not None:
                 if check_error:
                     # option validation
@@ -449,7 +460,7 @@ class Option(BaseOption):
                                        self._display_name,
                                        option_bag.ori_option,
                                        '{0}'.format(err),
-                                       err_index)
+                                       err_index) from err
             warnings.warn_explicit(ValueErrorWarning(val,
                                                      self._display_name,
                                                      option_bag.ori_option,
@@ -457,6 +468,8 @@ class Option(BaseOption):
                                                      err_index),
                                    ValueErrorWarning,
                                    self.__class__.__name__, 0)
+            return False
+        return True
 
     def _validate_calculator(self,
                             callback: Callable,

tiramisu/option/optiondescription.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2014-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2014-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -187,7 +187,8 @@ class OptionDescriptionWalk(CacheOptionDescription):
 
     async def get_children(self,
                            config_bag: Union[ConfigBag, Undefined],
-                           dyn: bool=True) -> Union[BaseOption, SynDynOptionDescription]:
+                           dyn: bool=True,
+                           ) -> Union[BaseOption, SynDynOptionDescription]:
         if not dyn or config_bag is undefined or \
                 config_bag.context.cfgimpl_get_description() == self:
             subpath = ''

tiramisu/option/passwordoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/portoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/stroption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/symlinkoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/syndynoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2018-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2018-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/syndynoptiondescription.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -84,7 +84,8 @@ class SynDynOptionDescription:
 
     async def get_children(self,
                            config_bag: ConfigBag,
-                           dyn: bool=True):
+                           dyn: bool=True,
+                           ):
         subpath = self.impl_getpath()
         children = []
         for child in await self._opt.get_children(config_bag):

tiramisu/option/urloption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/option/usernameoption.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2017-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/setting.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "sets the options of the configuration objects Config object itself"
-# Copyright (C) 2012-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2012-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -117,6 +117,7 @@ FORBIDDEN_SET_PERMISSIVES = frozenset(['force_default_on_freeze',
                                        'force_metaconfig_on_freeze',
                                        'force_store_value'])
 ALLOWED_LEADER_PROPERTIES = frozenset(['empty',
+                                       'notunique',
                                        'unique',
                                        'force_store_value',
                                        'mandatory',
@@ -458,10 +459,14 @@ class Settings(object):
                 elif apply_requires:
                     if not help_property:
                         new_prop = await prop.execute(option_bag,
-                                                      leadership_must_have_index=True)
+                                                      leadership_must_have_index=True,
+                                                      for_settings=True,
+                                                      )
                     else:
                         new_prop = await prop.help(option_bag,
-                                                   leadership_must_have_index=True)
+                                                   leadership_must_have_index=True,
+                                                   for_settings=True,
+                                                   )
                         if isinstance(new_prop, str):
                             new_prop = (new_prop, new_prop)
                     if new_prop is None:

tiramisu/storage/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/cache/dictionary.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2018-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2018-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/cacheobj.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "cache used by storage"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/dictionary/__init__.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/dictionary/setting.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "default plugin for setting: set it in a simple dictionary"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/dictionary/storage.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/dictionary/value.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "default plugin for value: set it in a simple dictionary"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -257,16 +257,12 @@ class Values:
                               connection,
                               path,
                               key,
-                              default):
+                              ):
         """retrieves one information's item
 
         :param key: the item string (ex: "help")
         """
-        value = self._storage.get_informations().get(path, {}).get(key, default)
-        if value is undefined:
-            raise ValueError(_("information's item"
-                               " not found: {0}").format(key))
-        return value
+        return self._storage.get_informations().get(path, {})[key]
 
     async def del_information(self,
                               connection,

tiramisu/storage/postgres/__init__.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2020-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/postgres/setting.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "default plugin for setting: set it in a simple dictionary"
-# Copyright (C) 2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2020-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/postgres/storage.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2020-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/postgres/value.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2020-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -186,7 +186,7 @@ class Values:
                               connection,
                               path,
                               key,
-                              default):
+                              ):
         """retrieves one information's item
 
         :param key: the item string (ex: "help")
@@ -197,12 +197,8 @@ class Values:
                                           "session_id = $2 AND path = $3",
                                           key, self._storage.database_id, path)
         if value is None:
-            if default is undefined:
-                raise ValueError(_("information's item"
-                                   " not found: {0}").format(key))
-            return default
-        else:
-            return loads(value)
+            raise KeyError()
+        return loads(value)
 
     async def del_information(self,
                               connection,

tiramisu/storage/sqlite3/__init__.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/sqlite3/setting.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "default plugin for setting: set it in a simple dictionary"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/sqlite3/sqlite3db.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "sqlite3"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/sqlite3/storage.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 " with sqlite3 engine"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/storage/sqlite3/value.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "default plugin for value: set it in a simple dictionary"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the

tiramisu/value.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 "takes care of the option's values and multi values"
-# Copyright (C) 2013-2020 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -57,11 +57,12 @@ class Values:
                                     None,
                                     new=True)
 
+
     #______________________________________________________________________
     # get value
-
     async def get_cached_value(self,
-                               option_bag):
+                               option_bag: OptionBag,
+                               ) -> Any:
         """get value directly in cache if set
         otherwise calculated value and set it in cache
 
@@ -75,31 +76,34 @@ class Values:
                                                      option_bag.index,
                                                      setting_properties,
                                                      option_bag.properties,
-                                                     'value')
-        if not validated:
-            # no cached value so get value
+                                                     'value',
+                                                     )
+        # no cached value so get value
+        if not is_cached:
             value = await self.getvalue(option_bag)
-            # validate value
-            await option_bag.option.impl_validate(value,
-                                                  option_bag,
-                                                  check_error=True)
-            # store value in cache
-            validator = 'validator' in setting_properties and 'demoting_error_warning' not in setting_properties
-            if not is_cached or validator:
-                cache.setcache(option_bag.path,
-                               option_bag.index,
-                               value,
-                               option_bag.properties,
-                               setting_properties,
-                               validator)
+        # validates and warns value
+        if not validated:
+            validate = await option_bag.option.impl_validate(value,
+                                                             option_bag,
+                                                             check_error=True,
+                                                             )
         if 'warnings' in setting_properties:
             await option_bag.option.impl_validate(value,
                                                   option_bag,
-                                                  check_error=False)
+                                                  check_error=False,
+                                                  )
+        # set value to cache
+        if not is_cached:
+            cache.setcache(option_bag.path,
+                           option_bag.index,
+                           value,
+                           option_bag.properties,
+                           setting_properties,
+                           validate,
+                           )
         if isinstance(value, list):
             # return a copy, so value cannot be modified
-            from copy import copy
-            value = copy(value)
+            value = value.copy()
         # and return it
         return value
 
@@ -169,8 +173,7 @@ class Values:
                          value,
                          reset_cache=True):
         if isinstance(value, Calculation):
-            value = await value.execute(option_bag,
-                                        leadership_must_have_index=True)
+            value = await value.execute(option_bag)
         elif isinstance(value, (list, tuple)):
             value = await self._do_value_list(value, option_bag)
         if reset_cache:
@@ -583,33 +586,53 @@ class Values:
     # information
 
     async def set_information(self,
-                              connection,
+                              config_bag,
+                              option_bag,
                               key,
                               value,
-                              path=None):
+                              ):
         """updates the information's attribute
 
         :param key: information's key (ex: "help", "doc"
         :param value: information's value (ex: "the help string")
         """
-        await self._p_.set_information(connection,
+        if option_bag is None:
+            path = None
+        else:
+            path = option_bag.path
+        await self._p_.set_information(config_bag.connection,
                                        path,
                                        key,
                                        value)
+        if path is not None:
+            for option in option_bag.option.get_dependencies_information(itself=True):
+                await config_bag.context.cfgimpl_reset_cache(option_bag)
 
     async def get_information(self,
-                              connection,
+                              config_bag,
+                              option_bag,
                               key,
-                              default=undefined,
-                              path=None):
+                              default,
+                              ):
         """retrieves one information's item
 
         :param key: the item string (ex: "help")
         """
-        return await self._p_.get_information(connection,
-                                              path,
-                                              key,
-                                              default)
+        if option_bag is None:
+            path = None
+        else:
+            path = option_bag.path
+        try:
+            return await self._p_.get_information(config_bag.connection,
+                                                  path,
+                                                  key,
+                                                  )
+        except KeyError as err:
+            if option_bag:
+                return option_bag.option.impl_get_information(key, default)
+            if default is not undefined:
+                return default
+            raise ValueError(_("information's item not found: {0}").format(key))
 
     async def del_information(self,
                               connection,