Merge remote-tracking branch 'official/master' into develop

ChangeLog

@@ -1,3 +1,8 @@
+Mon Apr  1 11:47:30 2019 +0200 Emmanuel Garette <egarette@cadoles.com>
+	* version 3.0 rc16
+	* tiramisu is now async
+	* add postgresql storage
+
 Mon Sep  2 14:10:40 2019 +0200 Emmanuel Garette <egarette@cadoles.com>
 	* version 3.0 rc15
 	* add parents method to MetaConfig

setup.py

@@ -1,11 +1,17 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from setuptools import setup, find_packages
+from setuptools import setup
 import os
 from tiramisu import __version__
 
 
-PACKAGE_NAME = os.environ.get('PACKAGE_DST', 'tiramisu')
+ORI_PACKAGE_NAME = 'tiramisu'
+PACKAGE_NAME = os.environ.get('PACKAGE_DST', ORI_PACKAGE_NAME)
+
+if PACKAGE_NAME != ORI_PACKAGE_NAME:
+    package_dir = {PACKAGE_NAME: ORI_PACKAGE_NAME}
+else:
+    package_dir = None
 
 setup(
     version=__version__,
@@ -40,5 +46,6 @@ producing flexible and fast options access.
 This version requires Python 3.5 or later.
 """,
     include_package_data=True,
-    packages=find_packages(include=['tiramisu'])
+    package_dir=package_dir,
+    packages=[PACKAGE_NAME],
 )

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_duplicate_config.py

@@ -59,6 +59,16 @@ async def test_copy():
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_copy_information():
+    od = make_description()
+    async with await Config(od) as cfg:
+        await cfg.information.set('key', 'value')
+        async with await cfg.config.copy() as ncfg:
+            assert await ncfg.information.get('key') == 'value'
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_copy_force_store_value():
     od = make_description()

tests/test_dyn_optiondescription.py

@@ -9,7 +9,9 @@ from tiramisu import BoolOption, StrOption, ChoiceOption, IPOption, \
     StrOption, PortOption, BroadcastOption, DomainnameOption, \
     EmailOption, URLOption, UsernameOption, FilenameOption, SymLinkOption, \
     OptionDescription, DynOptionDescription, SynDynOption, submulti, Leadership, \
-    Config, Params, ParamOption, ParamValue, ParamSuffix, ParamSelfOption, ParamIndex, Calculation, calc_value, \
+    Config, \
+    Params, ParamOption, ParamValue, ParamSuffix, ParamSelfOption, ParamDynOption, ParamIndex, \
+    Calculation, calc_value, \
     delete_session
 from tiramisu.error import PropertiesOptionError, ConfigError, ConflictError
 from tiramisu.storage import list_sessions
@@ -145,8 +147,8 @@ async def test_getdoc_dyndescription():
         assert await cfg.option('od.dodval2.stval2').option.name() == 'stval2'
         assert await cfg.option('od.dodval1').option.name() == 'dodval1'
         assert await cfg.option('od.dodval2').option.name() == 'dodval2'
-        assert await cfg.option('od.dodval1.stval1').option.doc() == 'doc1'
+        assert await cfg.option('od.dodval1.stval1').option.doc() == 'doc1val1'
-        assert await cfg.option('od.dodval2.stval2').option.doc() == 'doc1'
+        assert await cfg.option('od.dodval2.stval2').option.doc() == 'doc1val2'
         assert await cfg.option('od.dodval1').option.doc() == 'doc2val1'
         assert await cfg.option('od.dodval2').option.doc() == 'doc2val2'
     assert not await list_sessions()
@@ -258,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()
 
 
@@ -289,6 +313,56 @@ async def test_callback_dyndescription():
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_callback_dyndescription_outside_wrong_param():
+    lst = StrOption('lst', '', ['val1', 'val2'], multi=True)
+    st = StrOption('st', '', Calculation(return_dynval))
+    dod = DynOptionDescription('dod', '', [st], suffixes=Calculation(return_list, Params(ParamOption(lst))))
+    out = StrOption('out', '', Calculation(return_dynval, Params(ParamOption(st))))
+    od = OptionDescription('od', '', [dod, out])
+    od2 = OptionDescription('od', '', [od, lst])
+    async with await Config(od2) as cfg:
+        with pytest.raises(ConfigError):
+            await cfg.value.dict()
+    assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_callback_dyndescription_outside1():
+    lst = StrOption('lst', '', ['val1', 'val2'], multi=True)
+    st = StrOption('st', '', Calculation(return_dynval))
+    dod = DynOptionDescription('dod', '', [st], suffixes=Calculation(return_list, Params(ParamOption(lst))))
+    out = StrOption('out', '', Calculation(return_dynval, Params(ParamDynOption(st, 'val1', dod))))
+    od = OptionDescription('od', '', [dod, out])
+    od2 = OptionDescription('od', '', [od, lst])
+    async with await Config(od2) as cfg:
+        assert await cfg.value.dict() == {'od.dodval1.stval1': 'val', 'od.dodval2.stval2': 'val', 'od.out': 'val', 'lst': ['val1', 'val2']}
+        await cfg.option('od.dodval1.stval1').value.set('val1')
+        await cfg.option('od.dodval2.stval2').value.set('val2')
+        assert await cfg.value.dict() == {'od.dodval1.stval1': 'val1', 'od.dodval2.stval2': 'val2', 'od.out': 'val1', 'lst': ['val1', 'val2']}
+        await cfg.option('lst').value.set(['val2'])
+        with pytest.raises(ConfigError):
+            await cfg.value.dict()
+        await cfg.option('lst').value.set(['val1'])
+        assert await cfg.value.dict() == {'od.dodval1.stval1': 'val1', 'od.out': 'val1', 'lst': ['val1']}
+    assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_callback_dyndescription_outside2():
+    lst = StrOption('lst', '', ['val1', 'val2'], multi=True)
+    out = StrOption('out', '')
+    st = StrOption('st', '', Calculation(return_dynval, Params(ParamOption(out))))
+    dod = DynOptionDescription('dod', '', [st], suffixes=Calculation(return_list, Params(ParamOption(lst))))
+    od = OptionDescription('od', '', [dod, out])
+    od2 = OptionDescription('od', '', [od, lst])
+    async with await Config(od2) as cfg:
+        assert await cfg.value.dict() == {'od.dodval1.stval1': None, 'od.dodval2.stval2': None, 'od.out': None, 'lst': ['val1', 'val2']}
+        await cfg.option('od.out').value.set('val1')
+        assert await cfg.value.dict() == {'od.dodval1.stval1': 'val1', 'od.dodval2.stval2': 'val1', 'od.out': 'val1', 'lst': ['val1', 'val2']}
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_callback_list_dyndescription():
     st = StrOption('st', '', Calculation(return_list2, Params(ParamSuffix())), multi=True, properties=('notunique',))
@@ -590,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_freeze.py

@@ -187,26 +187,6 @@ async def test_force_store_value():
     assert not await list_sessions()
 
 
-@pytest.mark.asyncio
-async def test_force_store_value_leadership_follower():
-    b = IntOption('int', 'Test int option', multi=True)
-    c = StrOption('str', 'Test string option', multi=True, properties=('force_store_value',))
-    descr = Leadership("int", "", [b, c])
-    with pytest.raises(ConfigError):
-        cfg = await Config(descr, session_id='error')
-    await delete_session('error')
-    assert not await list_sessions()
-
-
-#@pytest.mark.asyncio
-#async def test_force_store_value_leadership():
-#    b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))
-#    c = StrOption('str', 'Test string option', multi=True)
-#    descr = Leadership("int", "", [b, c])
-#    cfg = await Config(descr)
-#    assert await cfg.value.get() == {'int': ('forced', ())}
-
-
 @pytest.mark.asyncio
 async def test_force_store_value_leadership_sub():
     b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))

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

@@ -358,6 +358,27 @@ async def test_meta_new_config_wrong_name():
     await delete_sessions(meta)
 
 
+@pytest.mark.asyncio
+async def test_meta_load_config():
+    od = make_description()
+    meta = await MetaConfig(['name1', 'name2'], optiondescription=od)
+    assert len(list(await meta.config.list())) == 2
+    await meta.config.load('name1')
+    assert len(list(await meta.config.list())) == 3
+    await delete_sessions(meta)
+
+
+@pytest.mark.asyncio
+async def test_meta_load_config_wrong_name():
+    od = make_description()
+    meta = await MetaConfig(['name1', 'name2'], optiondescription=od)
+    assert len(list(await meta.config.list())) == 2
+    with pytest.raises(ConfigError):
+        await meta.config.load('name3')
+    assert len(list(await meta.config.list())) == 2
+    await delete_sessions(meta)
+
+
 @pytest.mark.asyncio
 async def test_meta_meta_set():
     meta = await make_metaconfig(double=True)
@@ -1109,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
+    valid_ip_netmask, ParamSelfOption, ParamInformation, ParamSelfInformation
 from tiramisu.error import PropertiesOptionError, ConflictError, LeadershipError, ConfigError
 from tiramisu.i18n import _
 from tiramisu.storage import list_sessions
@@ -43,6 +43,10 @@ def return_value(value=None):
     return value
 
 
+async def return_async_value(value=None):
+    return value
+
+
 def return_value2(*args, **kwargs):
     value = list(args)
     value.extend(kwargs.values())
@@ -333,6 +337,72 @@ async def test_callback_value(config_type):
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_callback_async_value(config_type):
+    val1 = StrOption('val1', "", 'val')
+    val2 = StrOption('val2', "", Calculation(return_async_value, Params(ParamOption(val1))))
+    val3 = StrOption('val3', "", Calculation(return_async_value, Params(ParamValue('yes'))))
+    val4 = StrOption('val4', "", Calculation(return_async_value, Params(kwargs={'value': ParamOption(val1)})))
+    val5 = StrOption('val5', "", Calculation(return_async_value, Params(ParamValue('yes'))))
+    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4, val5])
+    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() == 'val'
+        assert await cfg.option('val2').value.get() == 'val'
+        assert await cfg.option('val4').value.get() == 'val'
+        await cfg.option('val1').value.set('new-val')
+        assert await cfg.option('val1').value.get() == 'new-val'
+        assert await cfg.option('val2').value.get() == 'new-val'
+        assert await cfg.option('val4').value.get() == 'new-val'
+        await cfg.option('val1').value.reset()
+        assert await cfg.option('val1').value.get() == 'val'
+        assert await cfg.option('val2').value.get() == 'val'
+        assert await cfg.option('val3').value.get() == 'yes'
+        assert await cfg.option('val4').value.get() == 'val'
+        assert await cfg.option('val5').value.get() == 'yes'
+    assert not await list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_callback_information(config_type):
+    val1 = StrOption('val1', "", Calculation(return_value, Params(ParamInformation('information', 'no_value'))))
+    val2 = StrOption('val2', "", Calculation(return_value, Params(ParamInformation('information'))))
+    maconfig = OptionDescription('rootconfig', '', [val1, val2])
+    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'
+        with pytest.raises(ConfigError):
+            await cfg.option('val2').value.get()
+        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()
+
+
 @pytest.mark.asyncio
 async def test_callback_value_tuple(config_type):
     val1 = StrOption('val1', "", 'val1')
@@ -1228,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',))
@@ -1433,11 +1518,14 @@ async def test_calc_value_remove_duplicate(config_type):
 async def test_calc_value_join(config_type):
     val1 = StrOption('val1', "", 'val1')
     val2 = StrOption('val2', "", 'val2')
-    val3 = StrOption('val3', "", Calculation(calc_value, Params((ParamOption(val1), ParamOption(val2)), join=ParamValue('.'))))
+    val3 = StrOption('val3', "")
-    od = OptionDescription('root', '', [val1, val2, val3])
+    val4 = StrOption('val4', "", Calculation(calc_value, Params((ParamOption(val1), ParamOption(val2), ParamOption(val3)), join=ParamValue('.'))))
+    od = OptionDescription('root', '', [val1, val2, val3, val4])
     async with await Config(od) as cfg:
         cfg = await get_config(cfg, config_type)
-        assert await cfg.value.dict() == {'val1': 'val1', 'val2': 'val2', 'val3': 'val1.val2'}
+        assert await cfg.value.dict() == {'val1': 'val1', 'val2': 'val2', 'val3': None, 'val4': None}
+        await cfg.option('val3').value.set('val3')
+        assert await cfg.value.dict() == {'val1': 'val1', 'val2': 'val2', 'val3': 'val3', 'val4': 'val1.val2.val3'}
     assert not await list_sessions()
 
 

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)

tests/test_submulti.py

@@ -5,7 +5,6 @@ import pytest
 import warnings
 
 
-from tiramisu.api import TIRAMISU_VERSION
 from tiramisu.setting import groups, owners
 from tiramisu import StrOption, IntOption, OptionDescription, submulti, Leadership, Config, \
                      MetaConfig, undefined, Params, ParamOption, Calculation
@@ -38,11 +37,7 @@ async def test_unknown_multi():
 @pytest.mark.asyncio
 async def test_submulti():
     multi = StrOption('multi', '', multi=submulti)
-    if TIRAMISU_VERSION == 2:
+    multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
-        default_multi = 'yes'
-    else:
-        default_multi = ['yes']
-    multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
     multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
     od = OptionDescription('od', '', [multi, multi2, multi3])
     async with await Config(od) as cfg:
@@ -66,11 +61,7 @@ async def test_submulti_default_multi_not_list():
 @pytest.mark.asyncio
 async def test_append_submulti():
     multi = StrOption('multi', '', multi=submulti)
-    if TIRAMISU_VERSION == 2:
+    multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
-        default_multi = 'yes'
-    else:
-        default_multi = ['yes']
-    multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
     multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
     od = OptionDescription('od', '', [multi, multi2, multi3])
     async with await Config(od) as cfg:
@@ -104,11 +95,7 @@ async def test_append_submulti():
 @pytest.mark.asyncio
 async def test_append_unvalide_submulti():
     multi = StrOption('multi', '', multi=submulti)
-    if TIRAMISU_VERSION == 2:
+    multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
-        default_multi = 'yes'
-    else:
-        default_multi = ['yes']
-    multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
     multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
     od = OptionDescription('od', '', [multi, multi2, multi3])
     async with await Config(od) as cfg:
@@ -137,11 +124,7 @@ async def test_append_unvalide_submulti():
 @pytest.mark.asyncio
 async def test_pop_submulti():
     multi = StrOption('multi', '', multi=submulti)
-    if TIRAMISU_VERSION == 2:
+    multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
-        default_multi = 'yes'
-    else:
-        default_multi = ['yes']
-    multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
     multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
     od = OptionDescription('od', '', [multi, multi2, multi3])
     async with await Config(od) as cfg:
@@ -267,6 +250,27 @@ async def test_values_with_leader_and_followers_submulti():
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_values_with_leader_and_followers_submulti_default_multi():
+    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=submulti, default_multi=['255.255.0.0', '0.0.0.0'])
+    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()
+        owner = await cfg.owner.get()
+        assert interface1.impl_get_group_type() == groups.leadership
+        assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
+        await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
+        assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
+        assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.0.0', '0.0.0.0']
+        await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.147"])
+        await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
+        assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
+        assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == ['255.255.0.0', '0.0.0.0']
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_reset_values_with_leader_and_followers_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
@@ -429,6 +433,20 @@ async def test_callback_submulti():
     assert not await list_sessions()
 
 
+@pytest.mark.asyncio
+async def test_callback_submulti_follower():
+    multi = StrOption('multi', '', multi=True)
+    multi2 = StrOption('multi2', '', Calculation(return_list), multi=submulti)
+    od = Leadership('multi', '', [multi, multi2])
+    od = OptionDescription('multi', '', [od])
+    async with await Config(od) as cfg:
+        await cfg.property.read_write()
+        assert await cfg.option('multi.multi').value.get() == []
+        await cfg.option('multi.multi').value.set(['val'])
+        assert await cfg.option('multi.multi2', 0).value.get() == ['val', 'val']
+    assert not await list_sessions()
+
+
 @pytest.mark.asyncio
 async def test_submulti_unique():
     i = IntOption('int', '', multi=submulti, properties=('unique',))

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
@@ -17,8 +17,8 @@
 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, ParamSelfOption, ParamValue, \
+from .autolib import Calculation, Params, ParamOption, ParamDynOption, ParamSelfOption, \
-                     ParamIndex, ParamSuffix
+                     ParamValue, ParamIndex, ParamSuffix, ParamInformation, ParamSelfInformation
 from .option import *
 from .error import APIError
 from .api import Config, MetaConfig, GroupConfig, MixConfig
@@ -31,10 +31,13 @@ from .storage import default_storage, Storage, list_sessions, \
 allfuncs = ['Calculation',
             'Params',
             'ParamOption',
+            'ParamDynOption',
             'ParamSelfOption',
             'ParamValue',
             '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
@@ -52,7 +52,7 @@ class TiramisuHelp:
             if module_name in ['forcepermissive', 'unrestraint']:
                 force = True
                 max_len = max(max_len, len('forcepermissive'))
-            elif module_name is not 'help' and not module_name.startswith('_'):
+            elif module_name != 'help' and not module_name.startswith('_'):
                 modules.append(module_name)
                 max_len = max(max_len, len(module_name))
         modules.sort()
@@ -87,8 +87,8 @@ class CommonTiramisu(TiramisuHelp):
 
     async def _get_option(self,
                           connection) -> Any:
+        config_bag = self._option_bag.config_bag
         if not self._subconfig:
-            config_bag = self._option_bag.config_bag
             try:
                 subconfig, name = await config_bag.context.cfgimpl_get_home_by_path(self._option_bag.path,
                                                                                     config_bag,
@@ -101,7 +101,7 @@ class CommonTiramisu(TiramisuHelp):
             self._name = name
         option = self._option_bag.option
         if option is None:
-            option = await self._subconfig.cfgimpl_get_description().get_child(name,
+            option = await self._subconfig.cfgimpl_get_description().get_child(self._name,
                                                                                config_bag,
                                                                                self._subconfig.cfgimpl_get_path())
             self._option_bag.option = option
@@ -212,6 +212,17 @@ class _TiramisuOptionOptionDescription(CommonTiramisuOption):
         """Test if option has dependency"""
         return self._option_bag.option.impl_has_dependency(self_is_dep)
 
+    @option_and_connection
+    async def dependencies(self):
+        """Get dependencies from this option"""
+        options = []
+        for option in self._option_bag.option._get_dependencies(self._option_bag.config_bag.context):
+            options.append(TiramisuOption(option().impl_getpath(),
+                                          None,
+                                          self._option_bag.config_bag,
+                                          ))
+        return options
+
     @option_and_connection
     async def isoptiondescription(self):
         """Test if option is an optiondescription"""
@@ -453,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()
@@ -874,30 +885,53 @@ def connection(func):
 class TiramisuContextInformation(TiramisuConfig):
     """Manage config informations"""
     @connection
-    async def get(self, name, default=undefined):
+    async def get(self,
+                  name,
+                  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, name, value):
+    async def set(self,
+                  name,
+                  value,
+                  ):
         """Set an information"""
-        await self._config_bag.context.impl_set_information(self._config_bag.connection,
+        await self._config_bag.context.impl_set_information(self._config_bag,
                                                             name,
-                                                            value)
+                                                            value,
+                                                            )
 
     @connection
-    async def reset(self, name):
+    async def reset(self,
+                    name,
+                    ):
         """Remove an information"""
         await self._config_bag.context.impl_del_information(self._config_bag.connection,
-                                                            name)
+                                                            name,
+                                                            )
 
     @connection
     async def list(self):
         """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"""
@@ -1533,8 +1567,7 @@ class _TiramisuContextMixConfig(_TiramisuContextGroupConfig, _TiramisuContextCon
     async def new(self,
                   session_id,
                   storage=None,
-                  type='config',
+                  type='config'):
-                  new=None):
         """Create and add a new config"""
         config = self._config_bag.context
         if storage is None:
@@ -1545,7 +1578,26 @@ class _TiramisuContextMixConfig(_TiramisuContextGroupConfig, _TiramisuContextCon
                                                  session_id=session_id,
                                                  storage=storage,
                                                  type_=type,
-                                                 new=new)
+                                                 )
+        return await self._return_config(new_config,
+                                         storage)
+
+    async def load(self,
+                   session_id,
+                   storage=None,
+                   type='config',
+                   ):
+        """Create and add a new config"""
+        config = self._config_bag.context
+        if storage is None:
+            storage = config._storage
+        storage_obj = await storage.get()
+        async with storage_obj.Connection() as connection:
+            new_config = await config.load_config(connection,
+                                                  session_id=session_id,
+                                                  storage=storage,
+                                                  type_=type,
+                                                  )
         return await self._return_config(new_config,
                                          storage)
 

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
@@ -19,6 +19,7 @@
 # ____________________________________________________________
 "enables us to carry out a calculation and return an option's value"
 from typing import Any, Optional, Union, Callable, Dict, List
+from types import CoroutineType
 from itertools import chain
 
 from .error import PropertiesOptionError, ConfigError, LeadershipError, ValueWarning
@@ -81,6 +82,25 @@ class ParamOption(Param):
         self.raisepropertyerror = raisepropertyerror
 
 
+class ParamDynOption(ParamOption):
+    __slots__ = ('suffix',)
+    def __init__(self,
+                 option: 'Option',
+                 suffix: str,
+                 dynoptiondescription: 'DynOptionDescription',
+                 notraisepropertyerror: bool=False,
+                 raisepropertyerror: bool=False,
+                 todict: bool=False,
+                 ) -> None:
+        super().__init__(option,
+                         notraisepropertyerror,
+                         raisepropertyerror,
+                         todict,
+                         )
+        self.suffix = suffix
+        self.dynoptiondescription = dynoptiondescription
+
+
 class ParamSelfOption(Param):
     __slots__ = ('todict', 'whole')
     def __init__(self,
@@ -98,6 +118,20 @@ class ParamValue(Param):
         self.value = value
 
 
+class ParamInformation(Param):
+    __slots__ = ('information_name',)
+    def __init__(self,
+                 information_name: str,
+                 default_value: Any=undefined,
+                 ) -> None:
+        self.information_name = information_name
+        self.default_value = default_value
+
+
+class ParamSelfInformation(ParamInformation):
+    __slots__ = tuple()
+
+
 class ParamIndex(Param):
     __slots__ = tuple()
 
@@ -136,7 +170,10 @@ class Calculation:
                 option_bag: OptionBag,
                 leadership_must_have_index: bool=False,
                 orig_value: Any=undefined,
-                allow_raises=False) -> Any:
+                allow_value_error: bool=False,
+                force_value_warning: bool=False,
+                for_settings: bool=False,
+                ) -> Any:
         return await carry_out_calculation(option_bag.option,
                                            callback=self.function,
                                            callback_params=self.params,
@@ -144,20 +181,29 @@ class Calculation:
                                            config_bag=option_bag.config_bag,
                                            leadership_must_have_index=leadership_must_have_index,
                                            orig_value=orig_value,
-                                           allow_raises=allow_raises)
+                                           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'):
@@ -175,12 +221,14 @@ class Break(Exception):
     pass
 
 
-async def manager_callback(callbk: Union[ParamOption, ParamValue],
+async def manager_callback(callbk: Param,
                            option,
                            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:
@@ -214,7 +262,10 @@ async def manager_callback(callbk: Union[ParamOption, ParamValue],
             value = value[apply_index]
         return value
 
-    async def get_value(callbk, option_bag, path):
+    async def get_value(callbk,
+                        option_bag,
+                        path,
+                        ):
         try:
             # get value
             value = await config_bag.context.getattr(path,
@@ -227,6 +278,10 @@ async def manager_callback(callbk: Union[ParamOption, ParamValue],
                                 ', {}').format(option.impl_get_display_name(), err), err)
         except ValueError as err:
             raise ValueError(_('the option "{0}" is used in a calculation but is invalid ({1})').format(option_bag.option.impl_get_display_name(), err))
+        except AttributeError as err:
+            raise ConfigError(_('impossible to calculate "{0}", {1}').format(option_bag.option.impl_get_display_name(),
+                                                                             err,
+                                                                             ))
         return value
 
     async def get_option_bag(config_bag,
@@ -235,9 +290,11 @@ async def manager_callback(callbk: Union[ParamOption, ParamValue],
                              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_,
@@ -255,12 +312,32 @@ async def manager_callback(callbk: Union[ParamOption, ParamValue],
     if isinstance(callbk, ParamValue):
         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,
+                                                                 option_bag,
+                                                                 callbk.information_name,
+                                                                 callbk.default_value,
+                                                                 )
+        except ValueError as err:
+            raise ConfigError(_('option "{}" cannot be calculated: {}').format(option.impl_get_display_name(),
+                                                                               str(err),
+                                                                               ))
+
     if isinstance(callbk, ParamIndex):
         return index
 
     if isinstance(callbk, ParamSuffix):
         if not option.issubdyn():
-            raise ConfigError('option "{}" is not in a dynoptiondescription'.format(option.impl_get_display_name()))
+            raise ConfigError(_('option "{}" is not in a dynoptiondescription').format(option.impl_get_display_name()))
         return option.impl_getsuffix()
 
     if isinstance(callbk, ParamSelfOption):
@@ -272,41 +349,60 @@ async def manager_callback(callbk: Union[ParamOption, ParamValue],
         return {'name': option.impl_get_display_name(),
                 'value': value}
 
-    # it's ParamOption
+    if isinstance(callbk, ParamOption):
-    callbk_option = callbk.option
+        callbk_option = callbk.option
-    if callbk_option.issubdyn():
+        if callbk_option.issubdyn():
-        callbk_option = callbk_option.to_dynoption(option.rootpath,
+            if isinstance(callbk, ParamDynOption):
-                                                   option.impl_getsuffix(),
+                subdyn = callbk.dynoptiondescription
-                                                   callbk_option.getsubdyn())
+                rootpath = subdyn.impl_getpath() + callbk.suffix
-    if leadership_must_have_index and callbk_option.impl_get_leadership() and index is None:
+                suffix = callbk.suffix
-        raise Break()
+            else:
-    if config_bag is undefined:
+                if not option.impl_is_dynsymlinkoption():
-        return undefined
+                    msg = 'option "{}" is not dynamic but is an argument of the dynamic option "{}" in a callback'
-    if index is not None and callbk_option.impl_get_leadership() and \
+                    raise ConfigError(_(msg).format(option.impl_get_display_name(),
-            callbk_option.impl_get_leadership().in_same_group(option):
+                                                    callbk_option.impl_get_display_name(),
-        if not callbk_option.impl_is_follower():
+                                                    ))
-            # leader
+                #FIXME in same dynamic option?
-            index_ = None
+                rootpath = option.rootpath
-            with_index = True
+                suffix = option.impl_getsuffix()
+                subdyn = callbk_option.getsubdyn()
+            callbk_option = callbk_option.to_dynoption(rootpath,
+                                                       suffix,
+                                                       subdyn)
+        if leadership_must_have_index and callbk_option.impl_get_leadership() and index is None:
+            raise Break()
+        if config_bag is undefined:
+            return undefined
+        if index is not None and callbk_option.impl_get_leadership() and \
+                callbk_option.impl_get_leadership().in_same_group(option):
+            if not callbk_option.impl_is_follower():
+                # leader
+                index_ = None
+                with_index = True
+            else:
+                # follower
+                index_ = index
+                with_index = False
         else:
-            # follower
+            index_ = None
-            index_ = index
             with_index = False
-    else:
+        path = callbk_option.impl_getpath()
-        index_ = None
+        option_bag = await get_option_bag(config_bag,
-        with_index = False
+                                          callbk_option,
-    path = callbk_option.impl_getpath()
+                                          index_,
-    option_bag = await get_option_bag(config_bag,
+                                          False)
-                                      callbk_option,
+        value = await get_value(callbk,
-                                      index_,
+                                option_bag,
-                                      False)
+                                path,
-    value = await get_value(callbk, option_bag, path)
+                                )
-    if with_index:
+        if with_index:
-        value = value[index]
+            value = value[index]
-    if not callbk.todict:
+        if not callbk.todict:
-        return value
+            return value
-    return {'name': callbk_option.impl_get_display_name(),
+        return {'name': callbk_option.impl_get_display_name(),
-            'value': value}
+                'value': value}
+    raise ConfigError(_('unknown callback type {} in option {}').format(callbk,
+                                                                        option.impl_get_display_name()))
 
 
 async def carry_out_calculation(option,
@@ -316,18 +412,19 @@ async def carry_out_calculation(option,
                                 config_bag: Optional[ConfigBag],
                                 orig_value=undefined,
                                 leadership_must_have_index: bool=False,
-                                allow_raises: int=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
 
     :param option: the option
     :param callback: the name of the callback function
-    :type callback: str
     :param callback_params: the callback's parameters
                             (only keyword parameters are allowed)
-    :type callback_params: dict
     :param index: if an option is multi, only calculates the nth value
-    :type index: int
+    :param allow_value_error: to know if carry_out_calculation can return ValueError or ValueWarning (for example if it's a validation)
-    :param allow_raises: to know if carry_out_calculation is used to validate a value
+    :param force_value_warning: transform valueError to ValueWarning object
 
     The callback_params is a dict. Key is used to build args (if key is '')
     and kwargs (otherwise). Values are tuple of:
@@ -347,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:
@@ -364,13 +463,14 @@ async def carry_out_calculation(option,
                         kwargs[key] = {'propertyerror': str(err)}
             except Break:
                 continue
-    ret = calculate(option,
+    ret = await calculate(option,
-                    callback,
+                          callback,
-                    allow_raises,
+                          allow_value_error,
-                    args,
+                          force_value_warning,
-                    kwargs)
+                          args,
+                          kwargs)
     if isinstance(ret, list) and not option.impl_is_dynoptiondescription() and \
-            option.impl_is_follower():
+            option.impl_is_follower() and not option.impl_is_submulti():
         if args or kwargs:
             raise LeadershipError(_('the "{}" function with positional arguments "{}" '
                                     'and keyword arguments "{}" must not return '
@@ -389,11 +489,13 @@ async def carry_out_calculation(option,
     return ret
 
 
-def calculate(option,
+async def calculate(option,
-              callback: Callable,
+                    callback: Callable,
-              allow_raises: bool,
+                    allow_value_error: bool,
-              args,
+                    force_value_warning: bool,
-              kwargs):
+                    args,
+                    kwargs,
+                    ):
     """wrapper that launches the 'callback'
 
     :param callback: callback function
@@ -402,13 +504,16 @@ def calculate(option,
 
     """
     try:
-        return callback(*args, **kwargs)
+        ret = callback(*args, **kwargs)
-    except ValueError as err:
+        if isinstance(ret, CoroutineType):
-        if allow_raises:
+            ret = await ret
+        return ret
+    except (ValueError, ValueWarning) as err:
+        if allow_value_error:
+            if force_value_warning:
+                raise ValueWarning(str(err))
             raise err
         error = err
-    except ValueWarning as err:
-        raise err
     except Exception as err:
         # import traceback
         # traceback.print_exc()
@@ -425,5 +530,4 @@ 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
@@ -64,11 +64,11 @@ class SubConfig:
                 (not isinstance(descr, (BaseOption, SynDynOptionDescription)) or
                  not descr.impl_is_optiondescription()):
             try:
-                msg = descr.impl_get_displayname()
+                msg = descr.impl_get_display_name()
             except AttributeError:
                 msg = descr
-            raise TypeError(_('"{0}" must be an optiondescription, not an {1}'
+            raise TypeError(_('cannot create a sub config for "{0}" this is a "{1}", not an "OptionDescription"'
-                              ).format(msg, type(descr)))
+                              ).format(msg, descr.__class__.__name__))
         self._impl_descr = descr
         self._impl_context = context
         self._impl_path = subpath
@@ -111,8 +111,23 @@ 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):
+                    async for coption in self.cfgimpl_get_description().get_children_recursively(None,
+                                                                                                 None,
+                                                                                                 option_bag.config_bag):
+                        coption_bag = OptionBag()
+                        coption_bag.set_option(coption,
+                                               option_bag.index,
+                                               option_bag.config_bag)
+                        await self.reset_one_option_cache(option,
+                                                          resetted_opts,
+                                                          coption_bag,
+                                                          )
                     doption = option.to_dynoption(subpath,
                                                   suffix,
                                                   option)
@@ -120,7 +135,6 @@ 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)
                     await self.reset_one_option_cache(desc,
                                                       resetted_opts,
                                                       doption_bag)
@@ -139,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)
@@ -159,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:
@@ -168,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()
@@ -409,7 +431,8 @@ class SubConfig:
                               flatten,
                               fullpath,
                               pathsvalues,
-                              leader_to_list)
+                              leader_to_list,
+                              )
         return pathsvalues
 
     async def _make_dict(self,
@@ -422,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()
@@ -430,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,
@@ -550,27 +585,38 @@ class _CommonConfig(SubConfig):
 
     # information
     async def impl_set_information(self,
-                                   connection,
+                                   config_bag,
                                    key,
-                                   value):
+                                   value,
+                                   ):
         """updates the information's attribute
 
         :param key: information's key (ex: "help", "doc"
         :param value: information's value (ex: "the help string")
         """
-        await self._impl_values.set_information(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, []):
+            option_bag = OptionBag()
+            option_bag.set_option(option,
+                                  None,
+                                  config_bag)
+            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)
 
@@ -635,6 +681,9 @@ class _CommonConfig(SubConfig):
         duplicated_settings = duplicated_config.cfgimpl_get_settings()
         await duplicated_values._p_.importation(connection,
                                                 await self.cfgimpl_get_values()._p_.exportation(connection))
+        await duplicated_values._p_.importation_informations(connection,
+                                                             await self.cfgimpl_get_values()._p_.exportation_informations(connection),
+                                                             )
         properties = await self.cfgimpl_get_settings()._p_.exportation(connection)
         await duplicated_settings._p_.importation(connection,
                                                   properties)
@@ -1176,13 +1225,30 @@ class KernelMixConfig(KernelGroupConfig):
                          session_id,
                          type_='config',
                          storage=None,
-                         new=None,
                          ):
-        if new is None:
+        if session_id in [child.impl_getname() for child in self._impl_children]:
-            new = session_id not in await list_sessions()
-        if new and session_id in [child.impl_getname() for child in self._impl_children]:
             raise ConflictError(_('config name must be uniq in '
                                   'groupconfig for {0}').format(session_id))
+        return await self.load_config(connection,
+                                      session_id,
+                                      type_,
+                                      storage,
+                                      new=True,
+                                      )
+
+    async def load_config(self,
+                          connection,
+                          session_id,
+                          type_='config',
+                          storage=None,
+                          new=False,
+                          ):
+        if storage is None:
+            storage = self._storage
+        if not new:
+            if session_id not in await list_sessions(storage=storage):
+                raise ConfigError(_('cannot find existing config with session_id to "{}"').format(session_id))
+
         assert type_ in ('config', 'metaconfig', 'mixconfig'), _('unknown type {}').format(type_)
         if type_ == 'config':
             config = await KernelConfig(self._impl_descr,
@@ -1228,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
@@ -311,7 +311,10 @@ class CalcValue:
                                min_args_len)
         if not multi:
             if join is not None:
-                value = join.join(value)
+                if None not in value:
+                    value = join.join(value)
+                else:
+                    value = None
             elif value and operator:
                 new_value = value[0]
                 op = {'mul': mul,
@@ -330,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,
@@ -397,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
@@ -55,7 +55,8 @@ def get_translation() -> str:
         trans = translation(domain=app_name,
                             localedir=translations_path,
                             languages=[user_locale],
-                            codeset='UTF-8')
+                            )
+#                            codeset='UTF-8')
     except FileNotFoundError:
         log.debug('cannot found translation file for langage {} in localedir {}'.format(user_locale,
                                                                                         translations_path))

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'):
-            # if context is set in options, add those options
+            # 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,
@@ -270,20 +280,36 @@ class BaseOption(Base):
         return self.impl_get_callback()[0] is not None
 
     def _impl_get_display_name(self,
-                               dyn_name: Base=None) -> str:
+                               dyn_name: Base=None,
+                               suffix: str=None,
+                               ) -> str:
         name = self.impl_get_information('doc', None)
         if name is None or name == '':
             if dyn_name is not None:
                 name = dyn_name
             else:
                 name = self.impl_getname()
+        elif suffix:
+            name += suffix
         return name
 
-    def impl_get_display_name(self,
+    def _get_display_name(self,
-                              dyn_name: Base=None) -> str:
+                          dyn_name,
+                          suffix,
+                          ):
         if hasattr(self, '_display_name_function'):
-            return self._display_name_function(self, dyn_name)
+            return self._display_name_function(self,
-        return self._impl_get_display_name(dyn_name)
+                                               dyn_name,
+                                               suffix,
+                                               )
+        return self._impl_get_display_name(dyn_name,
+                                           suffix,
+                                           )
+
+    def impl_get_display_name(self) -> str:
+        return self._get_display_name(None,
+                                      None,
+                                      )
 
     def reset_cache(self,
                     path: str,

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
@@ -76,17 +76,18 @@ class ChoiceOption(Option):
         if isinstance(self._choice_values, Calculation):
             return
         values = self._choice_values
-        if values is not undefined and value not in values:
+        self.validate_values(value, values)
-            if len(values) == 1:
-                raise ValueError(_('only "{0}" is allowed'
-                                   '').format(values[0]))
-            raise ValueError(_('only {0} are allowed'
-                               '').format(display_list(values, add_quote=True)))
 
     async def validate_with_option(self,
                                    value: Any,
                                    option_bag: OptionBag) -> None:
         values = await self.impl_get_values(option_bag)
+        self.validate_values(value, values)
+
+    def validate_values(self,
+                        value,
+                        values,
+                        ) -> None:
         if values is not undefined and value not in values:
             if len(values) == 1:
                 raise ValueError(_('only "{0}" is allowed'

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
@@ -20,6 +20,8 @@
 # ____________________________________________________________
 import re
 from typing import List, Callable
+from itertools import chain
+from ..autolib import ParamOption
 
 
 from ..i18n import _
@@ -60,8 +62,14 @@ class DynOptionDescription(OptionDescription):
                                     'dynoptiondescription'))
             child._setsubdyn(self)
         # add suffixes
-        if __debug__ and isinstance(suffixes, Calculation):
+        if __debug__ and not isinstance(suffixes, Calculation):
-            self._suffixes = suffixes
+            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,
+                                             is_suffix=True,
+                                             )
+        self._suffixes = suffixes
 
     def convert_suffix_to_path(self,
                                suffix):
@@ -74,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
@@ -62,7 +62,9 @@ class IPOption(StrOption):
 
     def _validate_ip(self, value):
         try:
-            ip_address(value)
+            new_value = str(ip_address(value))
+            if value != new_value:
+                raise ValueError(f'should be {new_value}')
         except ValueError:
             raise ValueError()
 

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, ParamValue, ParamOption
+from ..autolib import Calculation, Params, ParamOption, ParamInformation, ParamSelfInformation
 from ..error import (ConfigError, ValueWarning, ValueErrorWarning, PropertiesOptionError,
                      ValueOptionError, display_list)
 from .syndynoption import SynDynOption
@@ -50,6 +50,7 @@ class Option(BaseOption):
                  #
                  '_validators',
                  #
+                 '_dependencies_information',
                  '_leadership',
                  '_choice_values',
                  '_choice_values_params',
@@ -66,6 +67,7 @@ class Option(BaseOption):
                  warnings_only: bool=False,
                  extra: Optional[Dict]=None):
         _setattr = object.__setattr__
+        _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))
@@ -84,7 +86,9 @@ class Option(BaseOption):
             is_multi = True
             _multi = submulti
         else:
-            raise ValueError(_('invalid multi type "{}"').format(multi))
+            raise ValueError(_('invalid multi type "{}" for "{}"').format(multi,
+                                                                          name,
+                                                                          ))
         if _multi != 1:
             _setattr(self, '_multi', _multi)
         if multi is not False and default is None:
@@ -93,17 +97,20 @@ class Option(BaseOption):
                          doc,
                          properties=properties,
                          is_multi=is_multi)
-        if __debug__:
+        if validators is not None:
-            if validators is not None:
+            if __debug__ and not isinstance(validators, list):
-                if not isinstance(validators, list):
+                raise ValueError(_('validators must be a list of Calculation for "{}"').format(name))
-                    raise ValueError(_('validators must be a list of Calculation for "{}"').format(name))
+            for validator in validators:
-                for validator in validators:
+                if __debug__ and not isinstance(validator, Calculation):
-                    if not isinstance(validator, Calculation):
+                    raise ValueError(_('validators must be a Calculation for "{}"').format(name))
-                        raise ValueError(_('validators must be a Calculation for "{}"').format(name))
+                for param in chain(validator.params.args, validator.params.kwargs.values()):
-                    for param in chain(validator.params.args, validator.params.kwargs.values()):
+                    if isinstance(param, ParamOption):
-                        if isinstance(param, ParamOption):
+                        param.option._add_dependency(self)
-                            param.option._add_dependency(self)
+                        self._has_dependency = True
-                            self._has_dependency = True
+                    elif isinstance(param, ParamSelfInformation):
+                        _dependencies_information[1].append(param.information_name)
+                    elif isinstance(param, ParamInformation):
+                        _dependencies_information[0].append(param.information_name)
 
                 self._validators = tuple(validators)
         if extra is not None and extra != {}:
@@ -154,29 +161,39 @@ class Option(BaseOption):
         self.sync_impl_validate(default,
                                 option_bag,
                                 check_error=False)
-        self.value_dependencies(default)
+        self.value_dependencies(default, _dependencies_information)
         if (is_multi and default != []) or \
                 (not is_multi and default is not None):
             if is_multi and isinstance(default, list):
                 default = tuple(default)
             _setattr(self, '_default', default)
+        if _dependencies_information[0] or _dependencies_information[1]:
+            self._dependencies_information = _dependencies_information
 
     def value_dependencies(self,
-                           value: Any) -> Any:
+                           value: Any,
+                           _dependencies_information: List[str],
+                           ) -> Any:
         if isinstance(value, list):
             for val in value:
                 if isinstance(value, list):
-                    self.value_dependencies(val)
+                    self.value_dependencies(val, _dependencies_information)
                 elif isinstance(value, Calculation):
-                    self.value_dependency(val)
+                    self.value_dependency(val, _dependencies_information)
         elif isinstance(value, Calculation):
-            self.value_dependency(value)
+            self.value_dependency(value, _dependencies_information)
 
     def value_dependency(self,
-                         value: Any) -> Any:
+                         value: Any,
+                         _dependencies_information: List[str],
+                         ) -> Any:
         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[0].append(param.information_name)
 
     #__________________________________________________________________________
     # option's information
@@ -190,6 +207,15 @@ class Option(BaseOption):
     def impl_is_dynsymlinkoption(self) -> bool:
         return False
 
+    def get_dependencies_information(self,
+                                     itself=False,
+                                     ) -> List[str]:
+        if itself:
+            idx = 1
+        else:
+            idx = 0
+        return getattr(self, '_dependencies_information', [[], []])[idx]
+
     def get_type(self) -> str:
         # _display_name for compatibility with older version than 3.0rc3
         return getattr(self, '_type', self._display_name)
@@ -307,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
@@ -315,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):
@@ -336,7 +363,9 @@ class Option(BaseOption):
                 if ((check_error and not calc_is_warnings_only) or
                         (not check_error and calc_is_warnings_only)):
                     try:
-                        kwargs = {'allow_raises': True}
+                        kwargs = {'allow_value_error': True,
+                                  'force_value_warning': calc_is_warnings_only,
+                                  }
                         if _index is not None and option_bag.index == _index:
                             soption_bag = option_bag
                         else:
@@ -347,17 +376,6 @@ class Option(BaseOption):
                         await validator.execute(soption_bag,
                                                 leadership_must_have_index=True,
                                                 **kwargs)
-                    except ValueError as err:
-                        if calc_is_warnings_only:
-                            warnings.warn_explicit(ValueWarning(val,
-                                                                self._display_name,
-                                                                self,
-                                                                '{0}'.format(err),
-                                                                _index),
-                                                   ValueWarning,
-                                                   self.__class__.__name__, 306)
-                        else:
-                            raise err
                     except ValueWarning as warn:
                         warnings.warn_explicit(ValueWarning(val,
                                                             self._display_name,
@@ -365,7 +383,7 @@ class Option(BaseOption):
                                                             '{0}'.format(warn),
                                                             _index),
                                                ValueWarning,
-                                               self.__class__.__name__, 316)
+                                               self.__class__.__name__, 356)
 
         async def do_validation(_value,
                                 _index):
@@ -373,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
@@ -442,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,
@@ -450,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
@@ -30,7 +30,9 @@ from ..error import ConfigError, ConflictError
 
 
 class CacheOptionDescription(BaseOption):
-    __slots__ = ('_cache_force_store_values',)
+    __slots__ = ('_cache_force_store_values',
+                 '_cache_dependencies_information',
+                 )
 
     def impl_already_build_caches(self) -> bool:
         return self.impl_is_readonly()
@@ -42,7 +44,9 @@ class CacheOptionDescription(BaseOption):
                            currpath: List[str]=None,
                            cache_option=None,
                            force_store_values=None,
-                           display_name=None) -> None:
+                           dependencies_information=None,
+                           display_name=None,
+                           ) -> None:
         """validate options and set option has readonly option
         """
         # _consistencies is None only when we start to build cache
@@ -52,6 +56,7 @@ class CacheOptionDescription(BaseOption):
             if __debug__:
                 cache_option = []
             force_store_values = []
+            dependencies_information = {}
             currpath = []
         else:
             init = False
@@ -73,17 +78,15 @@ class CacheOptionDescription(BaseOption):
                                           sub_currpath,
                                           cache_option,
                                           force_store_values,
+                                          dependencies_information,
                                           display_name)
             else:
+                for information in option.get_dependencies_information():
+                    dependencies_information.setdefault(information, []).append(option)
                 is_multi = option.impl_is_multi()
                 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 \
@@ -102,11 +105,13 @@ class CacheOptionDescription(BaseOption):
             option._set_readonly()
         if init:
             self._cache_force_store_values = force_store_values
+            self._cache_dependencies_information = dependencies_information
             self._path = self._name
             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()
@@ -134,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):
@@ -178,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
@@ -59,7 +59,9 @@ class SynDynOption:
         return self.opt.impl_getname() + self.suffix
 
     def impl_get_display_name(self) -> str:
-        return self.opt.impl_get_display_name(dyn_name=self.impl_getname()) + self.suffix
+        return self.opt._get_display_name(dyn_name=self.impl_getname(),
+                                          suffix=self.suffix,
+                                          )
 
     def impl_getsuffix(self) -> str:
         return self.suffix

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
@@ -25,14 +25,11 @@ from copy import deepcopy
 
 class Values:
     __slots__ = ('_values',
-                 '_informations',
                  '_storage',
                  '__weakref__')
     def __init__(self, storage):
         """init plugin means create values storage
         """
-        #self._values = ([], [], [], [])
-        #self._informations = {}
         self._storage = storage
 
     def _setvalue_info(self, nb, idx, value, index, follower_idx=None):
@@ -260,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,
@@ -296,6 +289,18 @@ class Values:
                                connection):
         self._storage.set_informations({})
 
+    async def exportation_informations(self,
+                                       connection,
+                                       ):
+        return deepcopy(self._storage.get_informations())
+
+    async def importation_informations(self,
+                                       connection,
+                                       informations,
+                                       ):
+        #deepcopy(informations)
+        return self._storage.set_informations(informations)
+
     async def exportation(self,
                           connection):
         return deepcopy(self._storage.get_values())

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,
@@ -231,6 +227,26 @@ class Values:
         await connection.execute("DELETE FROM information WHERE session_id = $1",
                                  self._storage.database_id)
 
+    async def exportation_informations(self,
+                                       connection,
+                                       ):
+        informations = {}
+        for path, key, value in await connection.fetch("SELECT path, key, value FROM information WHERE session_id = $1", self._storage.database_id):
+            path = self._storage.load_path(path)
+            informations.setdefault(path, {})[key] = loads(value)
+        return informations
+
+    async def importation_informations(self,
+                                       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)
+
     async def exportation(self,
                           connection):
         # log.debug('exportation')

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:
@@ -198,15 +201,27 @@ class Values:
         # now try to get default value:
         value = await self.calc_value(option_bag,
                                       option_bag.option.impl_getdefault())
-        if option_bag.option.impl_is_multi() and option_bag.index is not None and isinstance(value, (list, tuple)):
+        if option_bag.index is not None and isinstance(value, (list, tuple)):
-            # if index, must return good value for this index
+            if value and option_bag.option.impl_is_submulti():
-            if len(value) > option_bag.index:
+                # first index is a list, assume other data are list too
-                value = value[option_bag.index]
+                if isinstance(value[0], list):
-            else:
+                    # if index, must return good value for this index
-                # no value for this index, retrieve default multi value
+                    if len(value) > option_bag.index:
-                # default_multi is already a list for submulti
+                        value = value[option_bag.index]
-                value = await self.calc_value(option_bag,
+                    else:
-                                        option_bag.option.impl_getdefault_multi())
+                        # no value for this index, retrieve default multi value
+                        # default_multi is already a list for submulti
+                        value = await self.calc_value(option_bag,
+                                                      option_bag.option.impl_getdefault_multi())
+            elif option_bag.option.impl_is_multi():
+                # if index, must return good value for this index
+                if len(value) > option_bag.index:
+                    value = value[option_bag.index]
+                else:
+                    # no value for this index, retrieve default multi value
+                    # default_multi is already a list for submulti
+                    value = await self.calc_value(option_bag,
+                                            option_bag.option.impl_getdefault_multi())
         return value
 
     async def calculate_reset_cache(self,
@@ -227,9 +242,12 @@ 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) -> Any:
+                              option_bag: OptionBag,
+                              ) -> Any:
 
         # if value has callback, calculate value
         callback, callback_params = option_bag.option.impl_get_callback()
@@ -345,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]:
@@ -570,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,