Compare commits

...

55 Commits

Author SHA1 Message Date
ce0a46232d Merge remote-tracking branch 'official/master' into develop 2021-05-18 18:54:36 +02:00
64017d5cd4 import/export informations 2021-05-18 18:53:14 +02:00
b0462a1e80 . is no more unvalable 2021-05-18 18:52:42 +02:00
8b4af12217 Merge remote-tracking branch 'official/master' into develop 2021-05-16 06:52:38 +02:00
a5b6352188 calc_value: join with multi 2021-05-16 06:51:33 +02:00
75a073455e Merge remote-tracking branch 'official/master' into develop 2021-04-12 15:05:32 +02:00
87093da974 add test about deepcopy with multi parents 2021-04-03 20:38:08 +02:00
f7721a9775 manage force_store_value with dynoption 2021-04-03 20:24:27 +02:00
33f9cbdc64 allow caching with the demoting_error_warning property 2021-03-29 10:35:56 +02:00
6084487d08 add test to dyn optiondescription 2021-03-29 10:35:56 +02:00
9576809543 dict with leader_to_list parameter 2021-03-29 10:35:56 +02:00
af2d3eb3ce calculation with submulti 2021-03-29 10:35:56 +02:00
b76db42204 better error when value not in a choice 2021-03-29 10:35:56 +02:00
5858bcc00b Calculation to non-leader option with leader parameter is now possible 2021-03-29 10:35:56 +02:00
200562d23c manage callback with unrestraint 2021-03-29 10:35:56 +02:00
2f173af70f Add ParamSelfInformation 2021-03-29 10:35:56 +02:00
9a4faf391e 2020/2021 2021-03-29 10:35:56 +02:00
e2d5a1c8aa filename must be a full path 2021-03-29 10:35:56 +02:00
0bb066a8b8 exected could be a list 2021-03-29 10:35:56 +02:00
d3d4de7ae3 wrong leadership name in dict() 2021-03-29 10:35:56 +02:00
f0be02b80f better error message 2021-03-29 10:35:55 +02:00
b9107867c9 do not remove notempty and notunique properties 2021-03-29 10:35:55 +02:00
3b1dccd844 allow caching with the demoting_error_warning property 2021-03-21 14:51:12 +01:00
12174045a2 add test to dyn optiondescription 2021-03-18 09:00:28 +01:00
8972e796db dict with leader_to_list parameter 2021-03-18 09:00:04 +01:00
29282d8ea3 calculation with submulti 2021-03-18 08:57:22 +01:00
668ed3ad37 better error when value not in a choice 2021-03-18 08:54:59 +01:00
da946baba6 Calculation to non-leader option with leader parameter is now possible 2021-03-18 08:52:22 +01:00
0167f4e2d0 manage callback with unrestraint 2021-03-08 06:39:40 +01:00
acc86bc49f Add ParamSelfInformation 2021-03-06 19:23:35 +01:00
7ebad5724e 2020/2021 2021-02-24 20:30:04 +01:00
385160cabd filename must be a full path 2021-02-17 09:50:36 +01:00
99a422dad7 exected could be a list 2021-02-06 15:18:28 +01:00
bfed49a11f wrong leadership name in dict() 2021-01-11 22:40:25 +01:00
c9e166f1d4 better error message 2020-11-21 19:26:50 +01:00
da87f40f12 do not remove notempty and notunique properties 2020-11-03 22:34:57 +01:00
3e0e7244ef Merge remote-tracking branch 'official/master' into develop 2020-10-14 22:31:54 +02:00
e1fef11465 refactor 2020-10-05 21:16:41 +02:00
a269cbcc93 copy/deepcopy should duplicate informations 2020-10-05 20:27:17 +02:00
cd50225bad Merge remote-tracking branch 'official/master' into develop 2020-10-03 16:18:21 +02:00
6910371779 Add ParamInformation and callback can be a coroutine 2020-10-03 14:29:15 +02:00
afeedc1db6 config_bag and name not already exists 2020-08-15 00:23:48 +02:00
ba23a144ce Merge remote-tracking branch 'official/master' into develop 2020-08-12 11:59:50 +02:00
50d42624cc better support of PACKAGE_DST environment variable 2020-08-12 11:55:55 +02:00
659243ba8f better support for warnings_only 2020-08-04 16:49:21 +02:00
dc8010f0af calc_value with join parameter now work if an option is empty 2020-08-04 16:43:40 +02:00
96c76286db get dependencies in API 2020-08-04 16:35:40 +02:00
5c1d4afd56 remove unconsistent test 2020-08-04 16:35:10 +02:00
c4572ec409 remove codeset to i18n 2020-08-04 16:34:43 +02:00
2f125cfc8c better error for IP like 192.168.001.1 => 192.168.1.1 2020-08-04 16:33:52 +02:00
2d7729612b can load old session 2020-04-21 19:19:04 +02:00
86a48ce9f1 support callback with submulti 2020-04-21 17:13:25 +02:00
f437bb78f3 add a test with default_multi for a submulti follower 2020-04-21 09:16:29 +02:00
f7bd6e3a47 add support in calculation when option is in a dynoptiondescription 2020-04-11 13:13:35 +02:00
d71018a88e release 3.0rc16 2020-04-01 11:49:18 +02:00
67 changed files with 1328 additions and 399 deletions

View File

@ -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

View File

@ -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],
)

View File

@ -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()

View File

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

View File

@ -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()

View File

@ -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.dodval2.stval2').option.doc() == 'doc1'
assert await cfg.option('od.dodval1.stval1').option.doc() == 'doc1val1'
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):
await Config(od2, session_id='error')
await delete_session('error')
async with await Config(od2) as cfg:
await cfg.property.read_write()
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)

View File

@ -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',))

View File

@ -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()

View File

@ -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'])

View File

@ -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

View File

@ -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('.'))))
od = OptionDescription('root', '', [val1, val2, val3])
val3 = StrOption('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()

View File

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

View File

@ -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)

View File

@ -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:
default_multi = 'yes'
else:
default_multi = ['yes']
multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], 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:
default_multi = 'yes'
else:
default_multi = ['yes']
multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], 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:
default_multi = 'yes'
else:
default_multi = ['yes']
multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], 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:
default_multi = 'yes'
else:
default_multi = ['yes']
multi2 = StrOption('multi2', '', default_multi=default_multi, multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], 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',))

View File

@ -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, \
ParamIndex, ParamSuffix
from .autolib import Calculation, Params, ParamOption, ParamDynOption, ParamSelfOption, \
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',

View File

@ -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.connection,
key,
path=path)
except ValueError:
return self._option_bag.option.impl_get_information(key, default)
return await values.get_information(self._option_bag.config_bag,
self._option_bag,
key,
default,
)
@option_and_connection
async def set(self, key, value):
"""Set information"""
path = self._option_bag.path
values = self._option_bag.config_bag.context.cfgimpl_get_values()
await values.set_information(self._option_bag.config_bag.connection,
await values.set_information(self._option_bag.config_bag,
self._option_bag,
key,
value,
path=path)
)
@option_and_connection
async def reset(self,
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,
name,
default)
values = self._config_bag.context.cfgimpl_get_values()
return await values.get_information(self._config_bag,
None,
name,
default,
)
@connection
async def set(self, 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',
new=None):
type='config'):
"""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)

View File

@ -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

View File

@ -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
callbk_option = callbk.option
if callbk_option.issubdyn():
callbk_option = callbk_option.to_dynoption(option.rootpath,
option.impl_getsuffix(),
callbk_option.getsubdyn())
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
if isinstance(callbk, ParamOption):
callbk_option = callbk.option
if callbk_option.issubdyn():
if isinstance(callbk, ParamDynOption):
subdyn = callbk.dynoptiondescription
rootpath = subdyn.impl_getpath() + callbk.suffix
suffix = callbk.suffix
else:
if not option.impl_is_dynsymlinkoption():
msg = 'option "{}" is not dynamic but is an argument of the dynamic option "{}" in a callback'
raise ConfigError(_(msg).format(option.impl_get_display_name(),
callbk_option.impl_get_display_name(),
))
#FIXME in same dynamic option?
rootpath = option.rootpath
suffix = option.impl_getsuffix()
subdyn = callbk_option.getsubdyn()
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_ = index
index_ = None
with_index = False
else:
index_ = None
with_index = False
path = callbk_option.impl_getpath()
option_bag = await get_option_bag(config_bag,
callbk_option,
index_,
False)
value = await get_value(callbk, option_bag, path)
if with_index:
value = value[index]
if not callbk.todict:
return value
return {'name': callbk_option.impl_get_display_name(),
'value': value}
path = callbk_option.impl_getpath()
option_bag = await get_option_bag(config_bag,
callbk_option,
index_,
False)
value = await get_value(callbk,
option_bag,
path,
)
if with_index:
value = value[index]
if not callbk.todict:
return value
return {'name': callbk_option.impl_get_display_name(),
'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_raises: to know if carry_out_calculation is used to validate a value
:param allow_value_error: to know if carry_out_calculation can return ValueError or ValueWarning (for example if it's a validation)
: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,
callback,
allow_raises,
args,
kwargs)
ret = await calculate(option,
callback,
allow_value_error,
force_value_warning,
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,
callback: Callable,
allow_raises: bool,
args,
kwargs):
async def calculate(option,
callback: Callable,
allow_value_error: bool,
force_value_warning: bool,
args,
kwargs,
):
"""wrapper that launches the 'callback'
:param callback: callback function
@ -402,13 +504,16 @@ def calculate(option,
"""
try:
return callback(*args, **kwargs)
except ValueError as err:
if allow_raises:
ret = callback(*args, **kwargs)
if isinstance(ret, CoroutineType):
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)
raise ConfigError(msg) from error

View File

@ -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}'
).format(msg, type(descr)))
raise TypeError(_('cannot create a sub config for "{0}" this is a "{1}", not an "OptionDescription"'
).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:
new = session_id not in await list_sessions()
if new and session_id in [child.impl_getname() for child in self._impl_children]:
if 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 '
'groupconfig for {0}').format(config.impl_getname()))
raise ConflictError(_('config name "{0}" is not uniq in '
'groupconfig "{1}"').format(config.impl_getname(),
self.impl_getname()))
config.parents.append(weakref.ref(self))
self._impl_children.append(config)

View File

@ -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':

View File

@ -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:
value = []
elif remove_duplicate_value:
new_value = []
for val in value:
if val not in new_value:
new_value.append(val)
value = new_value
else:
if join is not None:
if None not in value:
length_val = None
for val in value:
if isinstance(val, list):
if None in val:
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:

View File

@ -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))

View File

@ -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

View File

@ -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:
properties = properties - {'notunique'}
else:
if 'notunique' not in properties:
properties = properties | {'unique'}
if 'notempty' in properties:
properties = properties - {'notempty'}
else:
if 'notempty' not in properties:
properties = properties | {'empty'}
assert isinstance(properties, frozenset), _('invalid properties type {0} for {1},'
' must be a frozenset').format(type(properties),
@ -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,
dyn_name: Base=None) -> str:
def _get_display_name(self,
dyn_name,
suffix,
):
if hasattr(self, '_display_name_function'):
return self._display_name_function(self, dyn_name)
return self._impl_get_display_name(dyn_name)
return self._display_name_function(self,
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,

View File

@ -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

View File

@ -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

View File

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

View File

@ -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

View File

@ -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

View File

@ -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):
self._suffixes = suffixes
if __debug__ and not isinstance(suffixes, Calculation):
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 ({})'

View File

@ -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

View File

@ -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 "/"'))

View File

@ -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

View File

@ -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

View File

@ -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()

View File

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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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 not isinstance(validators, list):
raise ValueError(_('validators must be a list of Calculation for "{}"').format(name))
for validator in validators:
if not isinstance(validator, Calculation):
raise ValueError(_('validators must be a Calculation for "{}"').format(name))
for param in chain(validator.params.args, validator.params.kwargs.values()):
if isinstance(param, ParamOption):
param.option._add_dependency(self)
self._has_dependency = True
if validators is not None:
if __debug__ and not isinstance(validators, list):
raise ValueError(_('validators must be a list of Calculation for "{}"').format(name))
for validator in validators:
if __debug__ and not isinstance(validator, Calculation):
raise ValueError(_('validators must be a Calculation for "{}"').format(name))
for param in chain(validator.params.args, validator.params.kwargs.values()):
if isinstance(param, ParamOption):
param.option._add_dependency(self)
self._has_dependency = True
elif isinstance(param, ParamSelfInformation):
_dependencies_information[1].append(param.information_name)
elif isinstance(param, ParamInformation):
_dependencies_information[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,

View File

@ -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_bag.set_option(option,
None,
config_bag)
option_bag.properties = frozenset()
await values._p_.setvalue(config_bag.connection,
subpath,
await values.getvalue(option_bag),
owners.forced,
option_bags = []
if option.issubdyn():
dynopt = option.getsubdyn()
rootpath = dynopt.impl_getpath()
subpaths = [rootpath] + option.impl_getpath()[len(rootpath) + 1:].split('.')[1:]
for suffix in await dynopt.get_suffixes(config_bag):
path_suffix = dynopt.convert_suffix_to_path(suffix)
subpath = '.'.join([subp + path_suffix for subp in subpaths])
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 = ''

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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):

View File

@ -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

View File

@ -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

View File

@ -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:

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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)
if value is undefined:
raise ValueError(_("information's item"
" not found: {0}").format(key))
return value
return self._storage.get_informations().get(path, {})[key]
async def del_information(self,
connection,
@ -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())

View File

@ -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

View File

@ -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

View File

@ -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

View File

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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

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