Merge branch 'develop' into dist/risotto/risotto-2.8.0/develop

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/with space.txt')
-        await cfg.option('a').value.set('tmp/')
+        await cfg.option('a').value.set('/tmp/with$.txt')
-        await cfg.option('a').value.set('tmp/text.txt')
         with pytest.raises(ValueError):
-            await cfg.option('a').value.set('/tmp/with space.txt')
+            await cfg.option('a').value.set('not starts with /')
-        with pytest.raises(ValueError):
-            await cfg.option('a').value.set('/tmp/with$.txt')
     assert not await list_sessions()
 
 

tests/test_dyn_optiondescription.py

@@ -260,9 +260,31 @@ async def test_prop_dyndescription_force_store_value():
     dod = DynOptionDescription('dod', '', [st], suffixes=Calculation(return_list))
     od = OptionDescription('od', '', [dod])
     od2 = OptionDescription('od', '', [od])
-    with pytest.raises(ConfigError):
+    async with await Config(od2) as cfg:
-        await Config(od2, session_id='error')
+        await cfg.property.read_write()
-    await delete_session('error')
+        assert await cfg.value.dict() == {'od.dodval1.stval1': None, 'od.dodval2.stval2': None}
+    assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_prop_dyndescription_force_store_value_calculation_prefix():
+    lst = StrOption('lst', '', ['val1', 'val2'], multi=True)
+    st = StrOption('st', '', Calculation(return_list, Params(ParamSuffix())) , properties=('force_store_value',))
+    dod = DynOptionDescription('dod', '', [st], suffixes=Calculation(return_list, Params(ParamOption(lst))))
+    od = OptionDescription('od', '', [dod, lst])
+    od2 = OptionDescription('od', '', [od])
+    async with await Config(od2) as cfg:
+        await cfg.property.read_write()
+        assert await cfg.option('od.dodval1.stval1').owner.isdefault() == False
+        assert await cfg.option('od.dodval2.stval2').owner.isdefault() == False
+        assert await cfg.value.dict() == {'od.lst': ['val1', 'val2'], 'od.dodval1.stval1': 'val1', 'od.dodval2.stval2': 'val2'}
+        #
+        await cfg.option('od.lst').value.set(['val1', 'val2', 'val3'])
+        assert await cfg.option('od.dodval3.stval3').owner.isdefault() == False
+        assert await cfg.option('od.dodval1.stval1').owner.isdefault() == False
+        assert await cfg.option('od.dodval2.stval2').owner.isdefault() == False
+        assert await cfg.value.dict() == {'od.lst': ['val1', 'val2', 'val3'], 'od.dodval1.stval1': 'val1', 'od.dodval2.stval2': 'val2', 'od.dodval3.stval3': 'val3'}
+
     assert not await list_sessions()
 
 
@@ -642,6 +664,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_metaconfig.py

@@ -1130,6 +1130,39 @@ async def test_meta_properties_meta_deepcopy():
     await delete_sessions([meta, meta2])
 
 
+@pytest.mark.asyncio
+async def test_meta_properties_meta_deepcopy_multi_parent():
+    ip_admin_eth0 = NetworkOption('ip_admin_eth0', "ip")
+    netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "mask")
+    interface1 = OptionDescription('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    conf1 = await Config(interface1, session_id='conf1')
+    conf2 = await Config(interface1, session_id='conf2')
+    await conf1.property.read_write()
+    await conf2.property.read_write()
+    meta1 = await MetaConfig([conf1, conf2], session_id='meta1')
+    await meta1.permissive.add('hidden')
+    await meta1.property.read_write()
+
+    meta2 = await MetaConfig(['name1', 'name2'], optiondescription=interface1, session_id='meta2')
+    await meta2.config.add(conf1)
+
+    await meta1.option('ip_admin_eth0').value.set('192.168.1.1')
+    await meta2.option('netmask_admin_eth0').value.set('255.255.255.0')
+
+    assert await meta1.value.dict() == {'ip_admin_eth0': '192.168.1.1', 'netmask_admin_eth0': None}
+    assert await meta2.value.dict() == {'ip_admin_eth0': None, 'netmask_admin_eth0': '255.255.255.0'}
+    assert await conf1.value.dict() == {'ip_admin_eth0': '192.168.1.1', 'netmask_admin_eth0': '255.255.255.0'}
+    assert await conf2.value.dict() == {'ip_admin_eth0': '192.168.1.1', 'netmask_admin_eth0': None}
+
+    copy_meta2 = await conf1.config.deepcopy(session_id='copy_conf1', metaconfig_prefix='copy_')
+    assert await copy_meta2.config.path() == 'copy_meta2'
+    copy_meta1 = await copy_meta2.config('copy_meta1')
+    copy_conf1 = await copy_meta1.config('copy_conf1')
+    assert await copy_meta2.value.dict() == {'ip_admin_eth0': None, 'netmask_admin_eth0': '255.255.255.0'}
+    assert await copy_conf1.value.dict() == {'ip_admin_eth0': '192.168.1.1', 'netmask_admin_eth0': '255.255.255.0'}
+    await delete_sessions([conf1, conf2, meta1, meta2, copy_conf1, copy_meta1, copy_meta2])
+
+
 @pytest.mark.asyncio
 async def test_meta_properties_submeta_deepcopy():
     ip_admin_eth0 = NetworkOption('ip_admin_eth0', "ip", multi=True, default=['192.168.1.1'])

tests/test_option.py

@@ -31,6 +31,18 @@ async def test_option_valid_name():
     with pytest.raises(ValueError):
         SymLinkOption(1, i)
     i = SymLinkOption("test1", i)
+#
+#
+#@pytest.mark.asyncio
+#async def test_option_unvalid_name():
+#    with pytest.raises(ValueError):
+#        IntOption('test.', '')
+#    with pytest.raises(ValueError):
+#        IntOption('test.val', '')
+#    with pytest.raises(ValueError):
+#        IntOption('.test', '')
+#    with pytest.raises(ValueError):
+#        OptionDescription('.test', '', [])
 
 
 @pytest.mark.asyncio

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('string2').property.get() == {'empty', 'notunique'}
-        assert await cfg.option('string3').property.get() == {'unique'}
+        assert await cfg.option('string3').property.get() == {'unique', 'notempty'}
-        assert await cfg.option('string4').property.get() == set()
+        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,28 +464,28 @@ 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,
-            return await values.get_information(self._option_bag.config_bag.connection,
+                                            self._option_bag,
-                                                key,
+                                            key,
-                                                path=path)
+                                            default,
-        except ValueError:
+                                            )
-            return self._option_bag.option.impl_get_information(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,
-              key):
+                    key: str,
+                    ) -> None:
         """Remove information"""
         path = self._option_bag.path
         values = self._option_bag.config_bag.context.cfgimpl_get_values()
@@ -890,10 +890,12 @@ class TiramisuContextInformation(TiramisuConfig):
                   default=undefined,
                   ):
         """Get an information"""
-        return await self._config_bag.context.impl_get_information(self._config_bag.connection,
+        values = self._config_bag.context.cfgimpl_get_values()
-                                                                   name,
+        return await values.get_information(self._config_bag,
-                                                                   default,
+                                            None,
-                                                                   )
+                                            name,
+                                            default,
+                                            )
 
     @connection
     async def set(self,
@@ -920,6 +922,16 @@ class TiramisuContextInformation(TiramisuConfig):
         """List information's keys"""
         return await self._config_bag.context.impl_list_information(self._config_bag.connection)
 
+    @connection
+    async def exportation(self):
+        """Export all informations"""
+        return await self._config_bag.context.cfgimpl_get_values()._p_.exportation_informations(self._config_bag.connection)
+
+    @connection
+    async def importation(self, informations):
+        """Import informations"""
+        return await self._config_bag.context.cfgimpl_get_values()._p_.importation_informations(self._config_bag.connection, informations)
+
 
 class TiramisuContextValue(TiramisuConfig):
     """Manage config value"""

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,
+                allow_value_error: bool=False,
-                force_value_warning=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,
                                                                  )
@@ -333,10 +358,11 @@ async def manager_callback(callbk: Param,
                 suffix = callbk.suffix
             else:
                 if not option.impl_is_dynsymlinkoption():
-                    msg = 'option "{}" is not dynamic in callback of the option "{}"'
+                    msg = 'option "{}" is not dynamic but is an argument of the dynamic option "{}" in a callback'
-                    raise ConfigError(_(msg).format(callbk_option.impl_get_display_name(),
+                    raise ConfigError(_(msg).format(option.impl_get_display_name(),
-                                                    option.impl_get_display_name(),
+                                                    callbk_option.impl_get_display_name(),
                                                     ))
+                #FIXME in same dynamic option?
                 rootpath = option.rootpath
                 suffix = option.impl_getsuffix()
                 subdyn = callbk_option.getsubdyn()
@@ -388,6 +414,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 +444,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 +530,4 @@ async def calculate(option,
                 '').format(str(error),
                            callback.__name__,
                            option.impl_get_display_name())
-    del error
+    raise ConfigError(msg) from error
-    raise ConfigError(msg)

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)
@@ -171,7 +173,8 @@ class SubConfig:
 
     async def cfgimpl_reset_cache(self,
                                   option_bag,
-                                  resetted_opts=None):
+                                  resetted_opts=None,
+                                  ):
         """reset all settings in cache
         """
         if resetted_opts is None:
@@ -180,9 +183,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 +431,8 @@ class SubConfig:
                               flatten,
                               fullpath,
                               pathsvalues,
-                              leader_to_list)
+                              leader_to_list,
+                              )
         return pathsvalues
 
     async def _make_dict(self,
@@ -434,6 +445,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 +465,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 +594,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 +606,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 +1294,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 '
+            raise ConflictError(_('config name "{0}" is not uniq in '
-                                  'groupconfig for {0}').format(config.impl_getname()))
+                                  '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
@@ -333,14 +333,39 @@ class CalcValue:
                         value = value[index]
                     else:
                         value = None
-        elif None in value and not allow_none:
+        else:
-            value = []
+            if join is not None:
-        elif remove_duplicate_value:
+                if None not in value:
-            new_value = []
+                    length_val = None
-            for val in value:
+                    for val in value:
-                if val not in new_value:
+                        if isinstance(val, list):
-                    new_value.append(val)
+                            if None in val:
-            value = new_value
+                                length_val = None
+                                break
+                            lval = len(val)
+                            if length_val is not None and length_val != lval:
+                                raise ValueError(_(f'unexpected value in calc_value with join attribute "{val}" with invalid length "{length_val}"'))
+                            length_val = lval
+                    new_value = []
+                    for idx in range(length_val):
+                        idx_val = []
+                        for val in value:
+                            if isinstance(val, list):
+                                idx_val.append(val[idx])
+                            else:
+                                idx_val.append(val)
+                        new_value.append(join.join(idx_val))
+                    value = new_value
+                else:
+                    value = []
+            elif None in value and not allow_none:
+                value = []
+            elif remove_duplicate_value:
+                new_value = []
+                for val in value:
+                    if val not in new_value:
+                        new_value.append(val)
+                value = new_value
         return value
 
     def value_from_kwargs(self,
@@ -400,7 +425,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()
 
@@ -40,6 +40,8 @@ submulti = 2
 def valid_name(name):
     if not isinstance(name, str):
         return False
+#    if '.' in name:
+#        return False
     return True
 
 
@@ -55,6 +57,7 @@ class Base:
                  '_properties',
                  '_has_dependency',
                  '_dependencies',
+                 '_suffixes_dependencies',
                  '__weakref__'
                 )
 
@@ -72,13 +75,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:
+            if 'notunique' not in properties:
-                properties = properties - {'notunique'}
-            else:
                 properties = properties | {'unique'}
-            if 'notempty' in properties:
+            if 'notempty' not in properties:
-                properties = properties - {'notempty'}
-            else:
                 properties = properties | {'empty'}
         assert isinstance(properties, frozenset), _('invalid properties type {0} for {1},'
                                                     ' must be a frozenset').format(type(properties),
@@ -103,18 +102,29 @@ class Base:
         return hasattr(self, '_dependencies')
 
     def _get_dependencies(self,
-                          context_od) -> Set[str]:
+                          context_od,
+                          ) -> Set[str]:
         ret = set(getattr(self, '_dependencies', STATIC_TUPLE))
         if context_od and hasattr(context_od, '_dependencies'):
             # add options that have context is set in calculation
             return set(context_od._dependencies) | ret
         return ret
 
+    def _get_suffixes_dependencies(self) -> Set[str]:
+        return getattr(self, '_suffixes_dependencies', STATIC_TUPLE)
+
     def _add_dependency(self,
-                        option) -> None:
+                        option,
+                        is_suffix: bool=False,
+                        ) -> None:
+        woption = weakref.ref(option)
         options = self._get_dependencies(None)
         options.add(weakref.ref(option))
         self._dependencies = tuple(options)
+        if is_suffix:
+            options = list(self._get_suffixes_dependencies())
+            options.append(weakref.ref(option))
+            self._suffixes_dependencies = tuple(options)
 
     def _impl_set_callback(self,
                            callback: Callable,

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'
+                raise ConfigError(_('the calculated values "{0}" for "{1}" is not a list'
-                                    '').format(self.impl_getname()))
+                                    '').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
@@ -66,7 +66,9 @@ class DynOptionDescription(OptionDescription):
             raise ConfigError(_('suffixes in dynoptiondescription has to be a calculation'))
         for param in chain(suffixes.params.args, suffixes.params.kwargs.values()):
             if isinstance(param, ParamOption):
-                param.option._add_dependency(self)
+                param.option._add_dependency(self,
+                                             is_suffix=True,
+                                             )
         self._suffixes = suffixes
 
     def convert_suffix_to_path(self,
@@ -80,6 +82,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):
+                    if default != []:
-                        raise ValueError(_('not allowed default value for follower option "{0}" '
+                        if child.impl_is_submulti() and isinstance(default, tuple):
-                                           'in leadership "{1}"'
+                            for val in default:
-                                           '').format(child.impl_get_display_name(),
+                                if not isinstance(val, Calculation):
-                                                      self.impl_get_display_name()))
+                                    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]:
+    def get_dependencies_information(self,
-        return getattr(self, '_dependencies_information', [])
+                                     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
@@ -87,11 +87,6 @@ class CacheOptionDescription(BaseOption):
                 if not option.impl_is_symlinkoption():
                     properties = option.impl_getproperties()
                     if 'force_store_value' in properties:
-                        if __debug__:
-                            if option.issubdyn():
-                                raise ConfigError(_('the dynoption "{0}" cannot have '
-                                                    '"force_store_value" property').format(
-                                                        option.impl_get_display_name()))
                         force_store_values.append((subpath, option))
                     if __debug__ and ('force_default_on_freeze' in properties or \
                             'force_metaconfig_on_freeze' in properties) and \
@@ -115,7 +110,8 @@ class CacheOptionDescription(BaseOption):
             self._set_readonly()
 
     async def impl_build_force_store_values(self,
-                                            config_bag: ConfigBag) -> None:
+                                            config_bag: ConfigBag,
+                                            ) -> None:
         if 'force_store_value' not in config_bag.properties:
             return
         values = config_bag.context.cfgimpl_get_values()
@@ -143,17 +139,37 @@ class CacheOptionDescription(BaseOption):
                                                   index,
                                                   False)
                 else:
-                    option_bag = OptionBag()
+                    option_bags = []
-                    option_bag.set_option(option,
+                    if option.issubdyn():
-                                          None,
+                        dynopt = option.getsubdyn()
-                                          config_bag)
+                        rootpath = dynopt.impl_getpath()
-                    option_bag.properties = frozenset()
+                        subpaths = [rootpath] + option.impl_getpath()[len(rootpath) + 1:].split('.')[1:]
-                    await values._p_.setvalue(config_bag.connection,
+                        for suffix in await dynopt.get_suffixes(config_bag):
-                                              subpath,
+                            path_suffix = dynopt.convert_suffix_to_path(suffix)
-                                              await values.getvalue(option_bag),
+                            subpath = '.'.join([subp + path_suffix for subp in subpaths])
-                                              owners.forced,
+                            doption = option.to_dynoption(subpath,
+                                                          suffix,
+                                                          option)
+                            doption_bag = OptionBag()
+                            doption_bag.set_option(doption,
+                                                   None,
+                                                   config_bag)
+                            option_bags.append(doption_bag)
+                    else:
+                        option_bag = OptionBag()
+                        option_bag.set_option(option,
                                               None,
-                                              False)
+                                              config_bag)
+                        option_bags.append(option_bag)
+                    for option_bag in option_bags:
+                        option_bag.properties = frozenset()
+                        await values._p_.setvalue(config_bag.connection,
+                                                  option_bag.path,
+                                                  await values.getvalue(option_bag),
+                                                  owners.forced,
+                                                  None,
+                                                  False,
+                                                  )
 
 
 class OptionDescriptionWalk(CacheOptionDescription):
@@ -187,7 +203,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)
+        return self._storage.get_informations().get(path, {})[key]
-        if value is undefined:
-            raise ValueError(_("information's item"
-                               " not found: {0}").format(key))
-        return value
 
     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 KeyError()
-                raise ValueError(_("information's item"
+        return loads(value)
-                                   " not found: {0}").format(key))
-            return default
-        else:
-            return loads(value)
 
     async def del_information(self,
                               connection,
@@ -244,7 +240,9 @@ class Values:
                                        connection,
                                        informations,
                                        ):
+        await self.del_informations(connection)
         for path, path_infos in informations.items():
+            path = self._storage.convert_path(path)
             for key, value in path_infos.items():
                 await connection.execute("INSERT INTO information(key, value, session_id, path) VALUES "
                                          "($1, $2, $3, $4)", key, dumps(value), self._storage.database_id, path)

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')
+                                                     'value',
-        if not validated:
+                                                     )
-            # no cached value so get value
+        # no cached value so get value
+        if not is_cached:
             value = await self.getvalue(option_bag)
-            # validate value
+        # validates and warns value
-            await option_bag.option.impl_validate(value,
+        if not validated:
-                                                  option_bag,
+            validate = await option_bag.option.impl_validate(value,
-                                                  check_error=True)
+                                                             option_bag,
-            # store value in cache
+                                                             check_error=True,
-            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)
         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 = value.copy()
-            value = copy(value)
         # 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,
+            value = await value.execute(option_bag)
-                                        leadership_must_have_index=True)
         elif isinstance(value, (list, tuple)):
             value = await self._do_value_list(value, option_bag)
         if reset_cache:
@@ -239,6 +242,8 @@ class Values:
             return
         # calculated value is a new value, so reset cache
         await option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
+        # and manage force_store_value
+        await self._set_force_value_suffix(option_bag)
 
     async def calculate_value(self,
                               option_bag: OptionBag,
@@ -358,15 +363,58 @@ class Values:
                                     check_error=False)
 
     async def _setvalue(self,
-                        option_bag,
+                        option_bag: OptionBag,
-                        value,
+                        value: Any,
-                        owner):
+                        owner: str,
+                        ) -> None:
         await option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
         await self._p_.setvalue(option_bag.config_bag.connection,
                                 option_bag.path,
                                 value,
                                 owner,
                                 option_bag.index)
+        await self._set_force_value_suffix(option_bag)
+
+    async def _set_force_value_suffix(self,
+                                      option_bag: OptionBag,
+                                      ) -> None:
+        if 'force_store_value' not in option_bag.config_bag.properties:
+            return
+        for woption in option_bag.option._get_suffixes_dependencies():
+            option = woption()
+            force_store_options = []
+            async for coption in option.get_children_recursively(None,
+                                                                 None,
+                                                                 option_bag.config_bag,
+                                                                 ):
+                if 'force_store_value' in coption.impl_getproperties():
+                    force_store_options.append(coption)
+            if not force_store_options:
+                continue
+            rootpath = option.impl_getpath()
+            settings = option_bag.config_bag.context.cfgimpl_get_settings()
+            for suffix in await option.get_suffixes(option_bag.config_bag):
+                for coption in force_store_options:
+                    subpaths = [rootpath] + coption.impl_getpath()[len(rootpath) + 1:].split('.')[:-1]
+                    path_suffix = option.convert_suffix_to_path(suffix)
+                    subpath = '.'.join([subp + path_suffix for subp in subpaths])
+                    doption = coption.to_dynoption(subpath,
+                                                   suffix,
+                                                   coption,
+                                                   )
+                    coption_bag = OptionBag()
+                    coption_bag.set_option(doption,
+                                           None,
+                                           option_bag.config_bag,
+                                           )
+                    coption_bag.properties = await settings.getproperties(coption_bag)
+                    await self._p_.setvalue(coption_bag.config_bag.connection,
+                                            coption_bag.path,
+                                            await self.getvalue(coption_bag),
+                                            owners.forced,
+                                            None,
+                                            False,
+                                            )
 
     async def _get_modified_parent(self,
                                    option_bag: OptionBag) -> Optional[OptionBag]:
@@ -583,33 +631,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,
+                              default,
-                              path=None):
+                              ):
         """retrieves one information's item
 
         :param key: the item string (ex: "help")
         """
-        return await self._p_.get_information(connection,
+        if option_bag is None:
-                                              path,
+            path = None
-                                              key,
+        else:
-                                              default)
+            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,