Infra
/
rougail
9
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

refactoring

This commit is contained in:
Emmanuel Garette 2020-07-20 18:13:53 +02:00
parent 05ca7ed578
commit 17e09354fa
584 changed files with 2532 additions and 833 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
src/rougail/annotator.py
View File

@ -10,8 +10,9 @@ import imp
from .i18n import _
from .utils import normalize_family
from .error import CreoleDictConsistencyError
from .error import DictConsistencyError
from .xmlreflector import HIGH_COMPATIBILITY
from .config import variable_namespace
#mode order is important
modes_level = ('basic', 'normal', 'expert')
@ -64,8 +65,6 @@ CONVERSION = {'number': int}
FREEZE_AUTOFREEZE_VARIABLE = 'module_instancie'
VARIABLE_NAMESPACE = 'rougail'
class ServiceAnnotator:
"""Manage service's object
@ -215,9 +214,11 @@ class ServiceAnnotator:
variable.type = type_
if type_ == 'symlink':
variable.opt = value
variable.multi = None
else:
variable.doc = key
val = self.objectspace.value()
val.type = type_
val.name = value
variable.value = [val]
self.paths.add_variable('services',
@ -274,7 +275,7 @@ class ServiceAnnotator:
if not hasattr(file_, 'source'):
file_.source = basename(file_.name)
elif not hasattr(file_, 'source'):
raise CreoleDictConsistencyError(_('attribute source mandatory for file with variable name '
raise DictConsistencyError(_('attribute source mandatory for file with variable name '
'for {}').format(file_.name))
@ -330,7 +331,7 @@ class SpaceAnnotator(object):
for variable in fam2.variable:
if variable.type == 'symlink' and '.' not in variable.name:
variable.opt = self.paths.get_variable_path(variable.opt,
VARIABLE_NAMESPACE,
variable_namespace,
)
def convert_helps(self):
@ -359,7 +360,7 @@ class SpaceAnnotator(object):
) -> None:
# manage leader's variable
if variable.multi is not True:
raise CreoleDictConsistencyError(_('the variable {} in a group must be multi').format(variable.name))
raise DictConsistencyError(_('the variable {} in a group must be multi').format(variable.name))
leader_space.variable = []
leader_space.name = leader_name
leader_space.hidden = variable.hidden
@ -400,7 +401,7 @@ class SpaceAnnotator(object):
leader_is_hidden: bool,
) -> None:
if variable.name != follower_names[0]:
raise CreoleDictConsistencyError(_('cannot found this follower {}').format(follower_names[0]))
raise DictConsistencyError(_('cannot found this follower {}').format(follower_names[0]))
follower_names.remove(variable.name)
if leader_is_hidden:
variable.frozen = True
@ -456,7 +457,7 @@ class SpaceAnnotator(object):
)
has_a_leader = True
else:
raise CreoleDictConsistencyError(_('cannot found followers {}').format(follower_names))
raise DictConsistencyError(_('cannot found followers {}').format(follower_names))
del self.space.constraints.group
def remove_empty_families(self): # pylint: disable=C0111,R0201
@ -531,6 +532,10 @@ class SpaceAnnotator(object):
variable.type = 'string'
if variable.type != 'symlink' and not hasattr(variable, 'description'):
variable.description = variable.name
if hasattr(variable, 'value'):
for value in variable.value:
if not hasattr(value, 'type'):
value.type = variable.type
def convert_auto_freeze(self): # pylint: disable=C0111
if hasattr(self.space, 'variables'):
@ -549,7 +554,7 @@ class SpaceAnnotator(object):
new_condition.param = [new_param]
new_target = self.objectspace.target()
new_target.type = 'variable'
if variables.name == VARIABLE_NAMESPACE:
if variables.name == variable_namespace:
path = variable.name
else:
path = variable.namespace + '.' + family.name + '.' + variable.name
@ -571,12 +576,12 @@ class SpaceAnnotator(object):
else:
choice.name = str(value)
except:
raise CreoleDictConsistencyError(_(f'unable to change type of a valid_enum entry "{value}" is not a valid "{type_}" for "{variable.name}"'))
raise DictConsistencyError(_(f'unable to change type of a valid_enum entry "{value}" is not a valid "{type_}" for "{variable.name}"'))
choices.append(choice.name)
choice.type = type_
variable.choice.append(choice)
if not variable.choice:
raise CreoleDictConsistencyError(_('empty valid enum is not allowed for variable {}').format(variable.name))
raise DictConsistencyError(_('empty valid enum is not allowed for variable {}').format(variable.name))
if hasattr(variable, 'value'):
for value in variable.value:
value.type = type_
@ -585,7 +590,7 @@ class SpaceAnnotator(object):
else:
cvalue = value.name
if cvalue not in choices:
raise CreoleDictConsistencyError(_('value "{}" of variable "{}" is not in list of all expected values ({})').format(value.name, variable.name, choices))
raise DictConsistencyError(_('value "{}" of variable "{}" is not in list of all expected values ({})').format(value.name, variable.name, choices))
else:
new_value = self.objectspace.value()
new_value.name = values[0]
@ -596,7 +601,7 @@ class SpaceAnnotator(object):
def _convert_valid_enum(self, variable, path):
if variable.type in FORCE_CHOICE:
if path in self.valid_enums:
raise CreoleDictConsistencyError(_('cannot set valid enum for variable with type {}').format(variable.type))
raise DictConsistencyError(_('cannot set valid enum for variable with type {}').format(variable.type))
self._set_valid_enum(variable, FORCE_CHOICE[variable.type], 'string')
if path in self.valid_enums:
values = self.valid_enums[path]['values']
@ -605,6 +610,7 @@ class SpaceAnnotator(object):
if path in self.force_value:
new_value = self.objectspace.value()
new_value.name = self.force_value[path]
new_value.type = variable.type
variable.value = [new_value]
del self.force_value[path]
@ -626,7 +632,7 @@ class SpaceAnnotator(object):
self._convert_valid_enum(variable, path)
# valid_enums must be empty now (all information are store in objects)
if self.valid_enums:
raise CreoleDictConsistencyError(_('valid_enum sets for unknown variables {}').format(self.valid_enums.keys()))
raise DictConsistencyError(_('valid_enum sets for unknown variables {}').format(self.valid_enums.keys()))
def change_variable_mode(self): # pylint: disable=C0111
if not hasattr(self.space, 'variables'):
@ -642,11 +648,11 @@ class SpaceAnnotator(object):
mode = modes_level[-1]
for follower in variable.variable:
if follower.auto_save is True:
raise CreoleDictConsistencyError(_('leader/followers {} '
raise DictConsistencyError(_('leader/followers {} '
'could not be '
'auto_save').format(follower.name))
if follower.auto_freeze is True:
raise CreoleDictConsistencyError(_('leader/followers {} '
raise DictConsistencyError(_('leader/followers {} '
'could not be '
'auto_freeze').format(follower.name))
if HIGH_COMPATIBILITY and variable.name != follower.name: # and variable.variable[0].mode != modes_level[0]:
@ -682,11 +688,11 @@ class SpaceAnnotator(object):
fill = fills[idx]
# test if it's redefined calculation
if fill.target in targets and not fill.redefine:
raise CreoleDictConsistencyError(_(f"A fill already exists for the target: {fill.target}"))
raise DictConsistencyError(_(f"A fill already exists for the target: {fill.target}"))
targets.append(fill.target)
#
if not fill.name in eosfunc:
raise CreoleDictConsistencyError(_('cannot find fill function {}').format(fill.name))
raise DictConsistencyError(_('cannot find fill function {}').format(fill.name))
namespace = fill.namespace
# let's replace the target by the path
@ -700,9 +706,9 @@ class SpaceAnnotator(object):
param_to_delete = []
for fill_idx, param in enumerate(fill.param):
if param.type not in TYPE_PARAM_FILL:
raise CreoleDictConsistencyError(_(f'cannot use {param.type} type as a param in a fill/auto'))
raise DictConsistencyError(_(f'cannot use {param.type} type as a param in a fill/auto'))
if param.type != 'string' and not hasattr(param, 'text'):
raise CreoleDictConsistencyError(_(f"All '{param.type}' variables shall have a value in order to calculate {fill.target}"))
raise DictConsistencyError(_(f"All '{param.type}' variables shall have a value in order to calculate {fill.target}"))
if param.type == 'variable':
try:
param.text, suffix = self.paths.get_variable_path(param.text,
@ -710,14 +716,13 @@ class SpaceAnnotator(object):
with_suffix=True)
if suffix:
param.suffix = suffix
except CreoleDictConsistencyError as err:
except DictConsistencyError as err:
if param.optional is False:
raise err
param_to_delete.append(fill_idx)
continue
if param.hidden is True:
param.transitive = False
param.hidden = None
else:
param.notraisepropertyerror = None
param_to_delete.sort(reverse=True)
for param_idx in param_to_delete:
fill.param.pop(param_idx)
@ -739,27 +744,27 @@ class SpaceAnnotator(object):
subpath = self.paths.get_variable_path(separator.name,
separator.namespace,
)
raise CreoleDictConsistencyError(_('{} already has a separator').format(subpath))
raise DictConsistencyError(_('{} already has a separator').format(subpath))
option.separator = separator.text
del family.separators
def load_params_in_validenum(self, param):
if param.type in ['string', 'python', 'number']:
if not hasattr(param, 'text') and (param.type == 'python' or param.type == 'number'):
raise CreoleDictConsistencyError(_("All '{}' variables shall be set in order to calculate {}").format(param.type, 'valid_enum'))
raise DictConsistencyError(_("All '{}' variables shall be set in order to calculate {}").format(param.type, 'valid_enum'))
if param.type in ['string', 'number']:
try:
values = literal_eval(param.text)
except ValueError:
raise CreoleDictConsistencyError(_('Cannot load {}').format(param.text))
raise DictConsistencyError(_('Cannot load {}').format(param.text))
elif param.type == 'python':
try:
#values = eval(param.text, {'eosfunc': self.eosfunc, '__builtins__': {'range': range, 'str': str}})
values = eval(param.text, {'eosfunc': self.eosfunc, '__builtins__': {'range': range, 'str': str}})
except NameError:
raise CreoleDictConsistencyError(_('The function {} is unknown').format(param.text))
raise DictConsistencyError(_('The function {} is unknown').format(param.text))
if not isinstance(values, list):
raise CreoleDictConsistencyError(_('Function {} shall return a list').format(param.text))
raise DictConsistencyError(_('Function {} shall return a list').format(param.text))
new_values = []
for val in values:
new_values.append(val)
@ -774,17 +779,19 @@ class SpaceAnnotator(object):
functions.extend(['valid_enum', 'valid_in_network', 'valid_differ'])
for check_idx, check in enumerate(self.space.constraints.check):
if not check.name in functions:
raise CreoleDictConsistencyError(_('cannot find check function {}').format(check.name))
raise DictConsistencyError(_('cannot find check function {}').format(check.name))
if hasattr(check, 'param'):
param_option_indexes = []
for idx, param in enumerate(check.param):
if param.type not in TYPE_PARAM_CHECK:
raise CreoleDictConsistencyError(_('cannot use {} type as a param in check for {}').format(param.type, check.target))
raise DictConsistencyError(_('cannot use {} type as a param in check for {}').format(param.type, check.target))
if param.type == 'variable' and not self.paths.path_is_defined(param.text):
if param.optional is True:
param_option_indexes.append(idx)
else:
raise CreoleDictConsistencyError(_(f'unknown param {param.text} in check'))
raise DictConsistencyError(_(f'unknown param {param.text} in check'))
if param.type != 'variable':
param.notraisepropertyerror = None
param_option_indexes = list(set(param_option_indexes))
param_option_indexes.sort(reverse=True)
for idx in param_option_indexes:
@ -818,27 +825,27 @@ class SpaceAnnotator(object):
proposed_value_type = self.objectspace.convert_boolean(param.text) == False
remove_params.append(param_idx)
except TypeError as err:
raise CreoleDictConsistencyError(_('cannot load checkval value for variable {}: {}').format(check.target, err))
raise DictConsistencyError(_('cannot load checkval value for variable {}: {}').format(check.target, err))
if proposed_value_type:
# no more supported
raise CreoleDictConsistencyError(_('cannot load checkval value for variable {}, no more supported').format(check.target))
raise DictConsistencyError(_('cannot load checkval value for variable {}, no more supported').format(check.target))
remove_params.sort(reverse=True)
for param_idx in remove_params:
del check.param[param_idx]
if len(check.param) != 1:
raise CreoleDictConsistencyError(_('cannot set more than one param '
raise DictConsistencyError(_('cannot set more than one param '
'for valid_enum for variable {}'
'').format(check.target))
param = check.param[0]
if check.target in self.valid_enums:
raise CreoleDictConsistencyError(_('valid_enum already set for {}'
raise DictConsistencyError(_('valid_enum already set for {}'
'').format(check.target))
if proposed_value_type:
if param.type == 'variable':
try:
values = self.load_params_in_validenum(param)
except NameError as err:
raise CreoleDictConsistencyError(_('cannot load value for variable {}: {}').format(check.target, err))
raise DictConsistencyError(_('cannot load value for variable {}: {}').format(check.target, err))
add_default_value = not check.is_in_leadership
if add_default_value and values:
self.force_value[check.target] = values[0]
@ -852,18 +859,13 @@ class SpaceAnnotator(object):
del self.space.constraints.check[idx]
def check_change_warning(self):
#convert level to "warnings_only" and hidden to "transitive"
#convert level to "warnings_only"
for check in self.space.constraints.check:
if check.level == 'warning':
check.warnings_only = True
else:
check.warnings_only = False
check.level = None
if hasattr(check, 'param'):
for param in check.param:
if not param.hidden is True:
check.transitive = False
param.hidden = None
def filter_check(self): # pylint: disable=C0111
# valid param in check
@ -889,20 +891,20 @@ class SpaceAnnotator(object):
elif name == 'valid_network_netmask':
params_len = 1
if len(check.param) != params_len:
raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
elif name == 'valid_ipnetmask':
params_len = 1
if len(check.param) != params_len:
raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
name = 'valid_ip_netmask'
elif name == 'valid_broadcast':
params_len = 2
if len(check.param) != params_len:
raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
elif name == 'valid_in_network':
params_len = 2
if len(check.param) != params_len:
raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
check_.name = name
check_.warnings_only = check.warnings_only
if hasattr(check, 'param'):
@ -918,13 +920,13 @@ class SpaceAnnotator(object):
for idx, target in enumerate(condition.target):
if target.type == 'variable':
if condition.source == target.name:
raise CreoleDictConsistencyError(_('target name and source name must be different: {}').format(condition.source))
raise DictConsistencyError(_('target name and source name must be different: {}').format(condition.source))
target.name = self.paths.get_variable_path(target.name, namespace)
elif target.type == 'family':
try:
target.name = self.paths.get_family_path(target.name, namespace)
except KeyError:
raise CreoleDictConsistencyError(_('cannot found family {}').format(target.name))
raise DictConsistencyError(_('cannot found family {}').format(target.name))
def convert_xxxlist_to_variable(self): # pylint: disable=C0111
# transform *list to variable or family
@ -958,21 +960,21 @@ class SpaceAnnotator(object):
for condition in self.space.constraints.condition:
if condition.name not in ['disabled_if_in', 'disabled_if_not_in', 'hidden_if_in', 'auto_hidden_if_not_in',
'hidden_if_not_in', 'mandatory_if_in', 'mandatory_if_not_in']:
raise CreoleDictConsistencyError(_(f'unknown condition {condition.name}'))
raise DictConsistencyError(_(f'unknown condition {condition.name}'))
def check_params(self):
for condition in self.space.constraints.condition:
for param in condition.param:
if param.type not in TYPE_PARAM_CONDITION:
raise CreoleDictConsistencyError(_(f'cannot use {param.type} type as a param in a condition'))
raise DictConsistencyError(_(f'cannot use {param.type} type as a param in a condition'))
def check_target(self):
for condition in self.space.constraints.condition:
if not hasattr(condition, 'target'):
raise CreoleDictConsistencyError(_('target is mandatory in condition'))
raise DictConsistencyError(_('target is mandatory in condition'))
for target in condition.target:
if target.type.endswith('list') and condition.name not in ['disabled_if_in', 'disabled_if_not_in']:
raise CreoleDictConsistencyError(_(f'target in condition for {target.type} not allow in {condition.name}'))
raise DictConsistencyError(_(f'target in condition for {target.type} not allow in {condition.name}'))
def check_condition_fallback_optional(self):
# a condition with a fallback **and** the source variable doesn't exist
@ -982,7 +984,7 @@ class SpaceAnnotator(object):
if condition.fallback is True and not self.paths.path_is_defined(condition.source):
for target in condition.target:
if target.type in ['variable', 'family']:
if target.name.startswith(VARIABLE_NAMESPACE + '.'):
if target.name.startswith(variable_namespace + '.'):
name = target.name.split('.')[-1]
else:
name = target.name
@ -1043,7 +1045,7 @@ class SpaceAnnotator(object):
if condition.param == []:
remove_targets = []
for target in condition.target:
if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
if target.name.startswith(f'{variable_namespace}.'):
name = target.name.split('.')[-1]
else:
name = target.name
@ -1071,7 +1073,7 @@ class SpaceAnnotator(object):
for condition in self.space.constraints.condition:
#parse each variable and family
for target_idx, target in enumerate(condition.target):
if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
if target.name.startswith(f'{variable_namespace}.'):
name = target.name.split('.')[-1]
else:
name = target.name
@ -1127,7 +1129,7 @@ class SpaceAnnotator(object):
else:
param = None
for target in condition.target:
if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
if target.name.startswith(f'{variable_namespace}.'):
name = target.name.split('.')[-1]
else:
name = target.name

2
src/rougail/config.py
View File

@ -15,3 +15,5 @@ dtdfilename = join(dtddir, 'rougail.dtd')
# chemin du répertoire source des fichiers templates
patch_dir = '/srv/rougail/patch'
variable_namespace = 'rougail'

2
src/rougail/data/rougail.dtd
View File

@ -140,7 +140,7 @@
<!ELEMENT param (#PCDATA)>
<!ATTLIST param type (string|variable|number|python) "string">
<!ATTLIST param name CDATA #IMPLIED>
<!ATTLIST param hidden (True|False) "True">
<!ATTLIST param notraisepropertyerror (True|False) "False">
<!ATTLIST param optional (True|False) "False">
<!ELEMENT target (#PCDATA)>

11
src/rougail/error.py
View File

@ -1,9 +1,4 @@
# -*- coding: utf-8 -*-
"""
Erreurs Creole
"""
class ConfigError(Exception):
pass
@ -19,7 +14,7 @@ class TemplateDisabled(TemplateError):
pass
class CreoleOperationError(Exception):
class OperationError(Exception):
"""Type error or value Error for Creole variable's type or values
"""
@ -30,11 +25,11 @@ class SpaceObjShallNotBeUpdated(Exception):
"""
class CreoleDictConsistencyError(Exception):
class DictConsistencyError(Exception):
"""It's not only that the Creole XML is valid against the Creole DTD
it's that it is not consistent.
"""
class CreoleLoaderError(Exception):
class LoaderError(Exception):
pass

650
src/rougail/loader.py
View File

@ -1,33 +1,16 @@
"""loader
flattened XML specific
"""
from os.path import join, isfile
from os.path import isfile
from lxml.etree import DTD
import imp
from tiramisu import (StrOption, OptionDescription, DynOptionDescription, PortOption,
IntOption, ChoiceOption, BoolOption, SymLinkOption, IPOption,
NetworkOption, NetmaskOption, DomainnameOption, BroadcastOption,
URLOption, EmailOption, FilenameOption, UsernameOption, DateOption,
PasswordOption, BoolOption, MACOption, Leadership, submulti,
Params, ParamSelfOption, ParamOption, ParamDynOption, ParamValue, Calculation, calc_value)
from .config import dtdfilename
from .config import dtdfilename, variable_namespace
from .i18n import _
from .utils import normalize_family
from .annotator import VARIABLE_NAMESPACE
from .error import CreoleLoaderError
from .error import LoaderError
FUNC_TO_DICT = ['valid_not_equal']
class ConvertDynOptionDescription(DynOptionDescription):
def convert_suffix_to_path(self, suffix):
if not isinstance(suffix, str):
suffix = str(suffix)
return normalize_family(suffix,
check_name=False)
FORCE_INFORMATIONS = ['help', 'test', 'separator']
def convert_boolean(value):
@ -54,90 +37,71 @@ def convert_tiramisu_value(value, type_):
return func(value)
CONVERT_OPTION = {'number': dict(opttype=IntOption, func=int),
'choice': dict(opttype=ChoiceOption),
'string': dict(opttype=StrOption),
'password': dict(opttype=PasswordOption),
'mail': dict(opttype=EmailOption),
'boolean': dict(opttype=BoolOption, initkwargs={'default': True}, func=convert_boolean),
'symlink': dict(opttype=SymLinkOption),
'filename': dict(opttype=FilenameOption),
'date': dict(opttype=DateOption),
'unix_user': dict(opttype=UsernameOption),
'ip': dict(opttype=IPOption, initkwargs={'allow_reserved': True}),
'local_ip': dict(opttype=IPOption, initkwargs={'private_only': True, 'warnings_only': True}),
'netmask': dict(opttype=NetmaskOption),
'network': dict(opttype=NetworkOption),
'broadcast': dict(opttype=BroadcastOption),
'netbios': dict(opttype=DomainnameOption, initkwargs={'type': 'netbios', 'warnings_only': True}),
'domain': dict(opttype=DomainnameOption, initkwargs={'type': 'domainname', 'allow_ip': True, 'allow_without_dot': True}),
'domain_strict': dict(opttype=DomainnameOption, initkwargs={'type': 'domainname', 'allow_ip': False}),
'hostname': dict(opttype=DomainnameOption, initkwargs={'type': 'hostname', 'allow_ip': True}),
'hostname_strict': dict(opttype=DomainnameOption, initkwargs={'type': 'hostname', 'allow_ip': False}),
'web_address': dict(opttype=URLOption, initkwargs={'allow_ip': True, 'allow_without_dot': True}),
'port': dict(opttype=PortOption, initkwargs={'allow_private': True}),
'mac': dict(opttype=MACOption),
'cidr': dict(opttype=IPOption, initkwargs={'cidr': True}),
'network_cidr': dict(opttype=NetworkOption, initkwargs={'cidr': True}),
CONVERT_OPTION = {'number': dict(opttype="IntOption", func=int),
'choice': dict(opttype="ChoiceOption"),
'string': dict(opttype="StrOption"),
'password': dict(opttype="PasswordOption"),
'mail': dict(opttype="EmailOption"),
'boolean': dict(opttype="BoolOption", initkwargs={'default': [True]}, func=convert_boolean),
'symlink': dict(opttype="SymLinkOption"),
'filename': dict(opttype="FilenameOption"),
'date': dict(opttype="DateOption"),
'unix_user': dict(opttype="UsernameOption"),
'ip': dict(opttype="IPOption", initkwargs={'allow_reserved': True}),
'local_ip': dict(opttype="IPOption", initkwargs={'private_only': True, 'warnings_only': True}),
'netmask': dict(opttype="NetmaskOption"),
'network': dict(opttype="NetworkOption"),
'broadcast': dict(opttype="BroadcastOption"),
'netbios': dict(opttype="DomainnameOption", initkwargs={'type': 'netbios', 'warnings_only': True}),
'domain': dict(opttype="DomainnameOption", initkwargs={'type': 'domainname', 'allow_ip': True, 'allow_without_dot': True}),
'domain_strict': dict(opttype="DomainnameOption", initkwargs={'type': 'domainname', 'allow_ip': False}),
'hostname': dict(opttype="DomainnameOption", initkwargs={'type': 'hostname', 'allow_ip': True}),
'hostname_strict': dict(opttype="DomainnameOption", initkwargs={'type': 'hostname', 'allow_ip': False}),
'web_address': dict(opttype="URLOption", initkwargs={'allow_ip': True, 'allow_without_dot': True}),
'port': dict(opttype="PortOption", initkwargs={'allow_private': True}),
'mac': dict(opttype="MACOption"),
'cidr': dict(opttype="IPOption", initkwargs={'cidr': True}),
'network_cidr': dict(opttype="NetworkOption", initkwargs={'cidr': True}),
}
class BaseElt:
def __init__(self, attrib):
self.attrib = attrib
class Common:
def populate_properties(self, child):
if child.get('type') == 'calculation':
kwargs = {'condition': child.attrib['source'],
'expected': ParamValue(child.attrib.get('expected'))}
if child.attrib['inverse'] == 'True':
kwargs['reverse_condition'] = ParamValue(True)
self.attrib['properties'].append((ParamValue(child.text), kwargs))
else:
self.attrib['properties'].append(child.text)
def build_properties(self):
for index, prop in enumerate(self.attrib['properties']):
if isinstance(prop, tuple):
action, kwargs = prop
kwargs['condition'] = ParamOption(self.storage.get(kwargs['condition']).get(), todict=True)
prop = Calculation(calc_value,
Params(action,
kwargs=kwargs))
self.attrib['properties'][index] = prop
if self.attrib['properties']:
self.attrib['properties'] = tuple(self.attrib['properties'])
else:
del self.attrib['properties']
class PopulateTiramisuObjects:
def __init__(self):
self.storage = ElementStorage()
self.booleans = []
def __init__(self,
xmlroot,
funcs_path,
):
self.storage = ElementStorage(self.parse_dtd())
self.storage.text = ["from tiramisu import *",
"from rougail.tiramisu import ConvertDynOptionDescription",
"import imp",
f"func = imp.load_source('func', '{funcs_path}')",
]
self.make_tiramisu_objects(xmlroot)
# parse object
self.storage.get('.').get()
def parse_dtd(self, dtdfilename):
"""Loads the Creole DTD
def parse_dtd(self):
"""Loads the DTD
:raises IOError: if the DTD is not found
:param dtdfilename: the full filename of the Creole DTD
:param dtdfilename: the full filename of the DTD
"""
if not isfile(dtdfilename):
raise IOError(_("no such DTD file: {}").format(dtdfilename))
booleans = []
with open(dtdfilename, 'r') as dtdfd:
dtd = DTD(dtdfd)
for elt in dtd.iterelements():
if elt.name == 'variable':
for attr in elt.iterattributes():
if set(attr.itervalues()) == set(['True', 'False']):
self.booleans.append(attr.name)
def make_tiramisu_objects(self, xmlroot, eosfunc):
self.eosfunc = imp.load_source('eosfunc', eosfunc)
booleans.append(attr.name)
return booleans
def make_tiramisu_objects(self,
xmlroot,
):
family = self.get_root_family()
for xmlelt in self.reorder_family(xmlroot):
self.iter_family(xmlelt,
@ -148,19 +112,18 @@ class PopulateTiramisuObjects:
def get_root_family(self):
family = Family(BaseElt({'name': 'baseoption',
'doc': 'baseoption'}),
self.booleans,
self.storage,
self.eosfunc,
False,
'.',
)
self.storage.add('.', family)
return family
def reorder_family(self, xmlroot):
xmlelts = []
for xmlelt in xmlroot:
# VARIABLE_NAMESPACE family has to be loaded before any other family
# because `extra` family could use `VARIABLE_NAMESPACE` variables.
if xmlelt.attrib['name'] == VARIABLE_NAMESPACE:
# variable_namespace family has to be loaded before any other family
# because `extra` family could use `variable_namespace` variables.
if xmlelt.attrib['name'] == variable_namespace:
xmlelts.insert(0, xmlelt)
else:
xmlelts.append(xmlelt)
@ -194,12 +157,10 @@ class PopulateTiramisuObjects:
elt,
)
family = Family(elt,
self.booleans,
self.storage,
self.eosfunc,
elt.tag == 'leader',
path,
)
self.storage.add(path, family)
parent_family.add(family)
if len(elt) != 0:
for child in elt:
@ -216,22 +177,18 @@ class PopulateTiramisuObjects:
is_follower = False
is_leader = False
if family.is_leader:
if elt.attrib['name'] != family.attrib['name']:
if elt.attrib['name'] != family.elt.attrib['name']:
is_follower = True
else:
is_leader = True
path = self.build_path(subpath,
elt,
)
variable = Variable(elt,
self.booleans,
family.add(Variable(elt,
self.storage,
is_follower,
is_leader,
self.eosfunc,
self.build_path(subpath,
elt,
)
self.storage.add(path, variable)
family.add(variable)
))
def build_path(self,
subpath,
@ -241,306 +198,299 @@ class PopulateTiramisuObjects:
return elt.attrib['name']
return subpath + '.' + elt.attrib['name']
def get_text(self):
return '\n'.join(self.storage.get('.').get_text())
class BaseElt:
def __init__(self, attrib):
self.attrib = attrib
def __iter__(self):
return iter([])
class ElementStorage:
def __init__(self):
def __init__(self,
booleans,
):
self.paths = {}
self.text = []
self.index = 0
self.booleans = booleans
def add(self, path, elt):
if path in self.paths:
raise CreoleLoaderError(_('path already loaded {}').format(path))
self.paths[path] = elt
self.paths[path] = (elt, self.index)
self.index += 1
def get(self, path):
if path not in self.paths or self.paths[path][0] is None:
raise LoaderError(_('there is no element for path {}').format(path))
return self.paths[path][0]
def get_name(self, path):
if path not in self.paths:
raise CreoleLoaderError(_('there is no element for path {}').format(path))
return self.paths[path]
raise LoaderError(_('there is no element for index {}').format(path))
return f'option_{self.paths[path][1]}'
class Common:
def __init__(self,
elt,
storage,
is_leader,
path,
):
self.option_name = None
self.path = path
self.attrib = {}
self.informations = {}
self.storage = storage
self.is_leader = is_leader
self.storage.add(self.path, self)
def populate_properties(self, child):
if child.get('type') == 'calculation':
action = f"ParamValue('{child.text}')"
option_name = self.storage.get(child.attrib['source']).get()
kwargs = f"'condition': ParamOption({option_name}, todict=True), 'expected': ParamValue('{child.attrib.get('expected')}')"
if child.attrib['inverse'] == 'True':
kwargs += ", 'reverse_condition': ParamValue(True)"
prop = 'Calculation(calc_value, Params(' + action + ', kwargs={' + kwargs + '}))'
else:
prop = "'" + child.text + "'"
if self.attrib['properties']:
self.attrib['properties'] += ', '
self.attrib['properties'] += prop
if not self.attrib['properties']:
del self.attrib['properties']
def get_attrib(self, attrib):
ret_list = []
for key, value in self.attrib.items():
if key == 'properties':
value = 'frozenset([' + self.attrib[key] + '])'
elif key in ['default', 'multi', 'suffixes', 'validators']:
value = self.attrib[key]
elif isinstance(value, str) and key != 'opt' and not value.startswith('['):
value = "'" + value.replace("'", "\\\'") + "'"
ret_list.append(f'{key}={value}')
return ', '.join(ret_list)
def populate_informations(self):
for key, value in self.informations.items():
value = value.replace('"', '\"')
self.storage.text.append(f'{self.option_name}.impl_set_information("{key}", "{value}")')
def get_text(self,
):
return self.storage.text
class Variable(Common):
def __init__(self, elt, booleans, storage, is_follower, is_leader, eosfunc):
self.option = None
self.informations = {}
self.attrib = {}
convert_option = CONVERT_OPTION[elt.attrib['type']]
if 'initkwargs' in convert_option:
self.attrib.update(convert_option['initkwargs'])
if elt.attrib['type'] != 'symlink':
self.attrib['properties'] = []
self.attrib['validators'] = []
self.eosfunc = eosfunc
self.storage = storage
self.booleans = booleans
self.populate_attrib(elt)
self.is_follower = is_follower
self.is_leader = is_leader
self.object_type = convert_option['opttype']
if 'multi' in self.attrib and self.attrib['multi']:
self.attrib['default'] = []
if self.is_follower:
self.attrib['default_multi'] = []
self.parse_children(elt)
if self.is_follower:
if self.attrib['multi'] is True:
self.attrib['multi'] = submulti
else:
self.attrib['multi'] = True
if elt.attrib['type'] == 'symlink':
self.attrib['opt'] = storage.get(self.attrib['opt'])
def parse_children(self,
def __init__(self,
elt,
storage,
is_follower,
is_leader,
path,
):
if elt.attrib['type'] == 'choice':
values = []
for child in elt:
super().__init__(elt,
storage,
is_leader,
path,
)
self.is_follower = is_follower
convert_option = CONVERT_OPTION[elt.attrib['type']]
del elt.attrib['type']
self.object_type = convert_option['opttype']
self.attrib.update(convert_option.get('initkwargs', {}))
if self.object_type != 'SymLinkOption':
self.attrib['properties'] = ''
self.attrib['validators'] = []
self.elt = elt
def get(self):
if self.option_name is None:
self.populate_attrib()
if self.object_type == 'SymLinkOption':
self.attrib['opt'] = self.storage.get(self.attrib['opt']).get()
else:
self.parse_multi()
self.parse_children()
attrib = self.get_attrib(self.attrib)
self.option_name = self.storage.get_name(self.path)
self.storage.text.append(f'{self.option_name} = {self.object_type}({attrib})')
self.populate_informations()
return self.option_name
def populate_attrib(self):
for key, value in self.elt.attrib.items():
if key in self.storage.booleans:
value = convert_boolean(value)
if key in FORCE_INFORMATIONS:
self.informations[key] = value
else:
self.attrib[key] = value
def parse_children(self):
if not 'default' in self.attrib or self.attrib['multi']:
self.attrib['default'] = []
if self.attrib['multi'] == 'submulti' and self.is_follower:
self.attrib['default_multi'] = []
choices = []
for child in self.elt:
if child.tag == 'property':
self.populate_properties(child)
elif child.tag == 'value':
if child.attrib.get('type') == 'calculation':
self.calc_value(child)
if child.attrib['type'] == 'calculation':
self.attrib['default'] = self.calculation_value(child, [])
else:
self.populate_value(child, elt)
self.populate_value(child)
elif child.tag == 'check':
self.populate_check(child)
self.attrib['validators'].append(self.calculation_value(child, ['ParamSelfOption()']))
elif child.tag == 'choice':
value = child.text
if child.attrib['type'] == 'number':
value = int(value)
values.append(value)
if elt.attrib['type'] == 'choice':
self.attrib['values'] = tuple(values)
def populate_attrib(self,
elt,
):
for key, value in elt.attrib.items():
if key == 'multi' and elt.attrib['type'] == 'symlink':
continue
if key in self.booleans:
if value == 'True':
value = True
elif value == 'False':
value = False
choices.append(convert_tiramisu_value(child.text, child.attrib['type']))
if choices:
self.attrib['values'] = tuple(choices)
if self.attrib['default'] == []:
del self.attrib['default']
elif not self.attrib['multi'] and isinstance(self.attrib['default'], list):
self.attrib['default'] = self.attrib['default'][-1]
if self.attrib['validators'] == []:
del self.attrib['validators']
else:
raise CreoleLoaderError(_('unknown value {} for {}').format(value, key))
if key in ['help', 'test', 'separator']:
self.add_information(key, value)
elif key != 'type':
self.attrib[key] = value
self.attrib['validators'] = '[' + ', '.join(self.attrib['validators']) + ']'
def calc_value(self, child):
args = []
kwargs = {}
if child.text is not None and child.text.strip():
function = child.text.strip()
else:
function = child.attrib['name']
for param in child:
self.parse_param(args,
kwargs,
param,
)
self.attrib['default'] = {'function': getattr(self.eosfunc, function),
'args': args,
'kwargs': kwargs,
'warnings_only': False}
def populate_value(self, child, elt):
if "type" in child.attrib:
type_ = child.attrib['type']
else:
type_ = elt.attrib['type']
value = convert_tiramisu_value(child.text, type_)
def parse_multi(self):
if self.is_follower:
if self.attrib['multi'] is True:
self.attrib['default_multi'].append(value)
self.attrib['multi'] = 'submulti'
else:
self.attrib['default_multi'] = value
elif self.attrib['multi'] is True:
self.attrib['default'].append(value)
if not self.is_leader:
self.attrib['default_multi'] = value
else:
self.attrib['default'] = value
self.attrib['multi'] = True
def populate_check(self, child):
args = [ParamSelfOption()]
kwargs = {}
def calculation_value(self, child, args):
kwargs = []
if 'name' in child.attrib:
# has parameters
function = child.attrib['name']
for param in child:
self.parse_param(args,
kwargs,
param,
)
self.attrib['validators'].append({'function': getattr(self.eosfunc, child.attrib['name']),
'args': args,
'kwargs': kwargs,
'warnings_only': convert_boolean(child.attrib['warnings_only'])})
value = self.populate_param(param)
if 'name' not in param.attrib:
args.append(str(value))
else:
kwargs.append(f"'{param.attrib['name']}': " + value)
else:
# function without any parameter
function = child.text.strip()
ret = f"Calculation(func.{function}, Params((" + ', '.join(args) + "), kwargs=" + "{" + ', '.join(kwargs) + "})"
if 'warnings_only' in child.attrib:
ret += f', warnings_only={child.attrib["warnings_only"]}'
return ret + ')'
def parse_param(self,
args,
kwargs,
def populate_param(self,
param,
):
if param.attrib['type'] == 'string':
value = ParamValue(param.text)
return f'ParamValue("{param.text}")'
elif param.attrib['type'] == 'number':
value = ParamValue(int(param.text))
return f'ParamValue({param.text})'
elif param.attrib['type'] == 'variable':
transitive = convert_boolean(param.attrib.get('transitive', 'False'))
value = {'option': param.text,
'notraisepropertyerror': transitive,
'notraisepropertyerror': convert_boolean(param.attrib['notraisepropertyerror']),
'todict': param.text in FUNC_TO_DICT,
}
if 'suffix' in param.attrib:
value['suffix'] = param.attrib['suffix']
else:
raise CreoleLoaderError(_('unknown param type {}').format(param.attrib['type']))
if 'name' not in param.attrib:
args.append(value)
else:
kwargs[param.attrib['name']] = value
return self.build_param(value)
raise LoaderError(_('unknown param type {}').format(param.attrib['type']))
def build_calculator(self, key):
def build_param(param):
option = self.storage.get(param['option']).get()
def populate_value(self,
child,
):
value = convert_tiramisu_value(child.text, child.attrib['type'])
if self.attrib['multi'] == 'submulti':
self.attrib['default_multi'].append(value)
elif self.is_follower:
self.attrib['default_multi'] = value
elif self.attrib['multi']:
self.attrib['default'].append(value)
if not self.is_leader:
self.attrib['default_multi'] = value
elif isinstance(value, int):
self.attrib['default'].append(value)
else:
self.attrib['default'].append("'" + value + "'")
def build_param(self,
param,
):
option_name = self.storage.get(param['option']).get()
if 'suffix' in param:
family = '.'.join(param['option'].split('.')[:-1])
return ParamDynOption(option,
param['suffix'],
self.storage.get(family).get(),
notraisepropertyerror=param['notraisepropertyerror'],
todict=param['todict'],
)
return ParamOption(option,
notraisepropertyerror=param['notraisepropertyerror'],
todict=param['todict'],
)
return param
def build_calculation(value):
args = []
kwargs = {}
for param in value['args']:
if isinstance(param, dict):
param = build_param(param)
args.append(param)
for key, param in value['kwargs'].items():
if isinstance(param, dict):
param = build_param(param)
kwargs[key] = param
return Calculation(value['function'],
Params(tuple(args),
kwargs=kwargs,
),
warnings_only=value['warnings_only'],
)
if key in self.attrib:
values = self.attrib[key]
if isinstance(values, list):
self.attrib[key] = []
for value in values:
if isinstance(value, dict):
value = build_calculation(value)
self.attrib[key].append(value)
else:
if isinstance(values, dict):
values = build_calculation(values)
self.attrib[key] = values
def add_information(self, key, value):
if key in self.informations:
raise CreoleLoaderError(_('key already exists in information {}').format(key))
self.informations[key] = value
def get(self):
if self.option is None:
if self.object_type is SymLinkOption:
self.attrib['opt'] = self.attrib['opt'].get()
else:
self.build_properties()
self.build_calculator('default')
self.build_calculator('validators')
if not self.attrib['validators']:
del self.attrib['validators']
try:
option = self.object_type(**self.attrib)
except Exception as err:
import traceback
traceback.print_exc()
name = self.attrib['name']
raise CreoleLoaderError(_('cannot create option "{}": {}').format(name, err))
for key, value in self.informations.items():
option.impl_set_information(key, value)
self.option = option
return self.option
family_option = self.storage.get_name(family)
return f"ParamDynOption({option_name}, '{param['suffix']}', {family_option}, notraisepropertyerror={param['notraisepropertyerror']}, todict={param['todict']})"
return f"ParamOption({option_name}, notraisepropertyerror={param['notraisepropertyerror']}, todict={param['todict']})"
class Family(Common):
def __init__(self,
elt,
booleans,
storage,
eosfunc,
is_leader=False,
is_leader,
path,
):
self.option = None
self.attrib = {}
self.is_leader = False
self.informations = {}
super().__init__(elt,
storage,
is_leader,
path,
)
self.children = []
self.storage = storage
self.eosfunc = eosfunc
self.attrib['properties'] = []
for key, value in elt.attrib.items():
if key == 'help':
self.add_information(key, value)
else:
self.attrib[key] = value
if not isinstance(elt, BaseElt) and len(elt) != 0:
for child in elt:
if child.tag == 'property':
self.populate_properties(child)
self.is_leader = is_leader
self.elt = elt
def add(self, child):
self.children.append(child)
def add_information(self, key, value):
if key in self.informations and not (key == 'icon' and self.informations[key] is None):
raise CreoleLoaderError(_('key already exists in information {}').format(key))
self.informations[key] = value
def get(self):
if self.option is None:
self.attrib['children'] = []
for child in self.children:
self.attrib['children'].append(child.get())
self.build_properties()
try:
if 'dynamic' in self.attrib:
dynamic = self.storage.get(self.attrib['dynamic']).get()
del self.attrib['dynamic']
self.attrib['suffixes'] = Calculation(self.eosfunc.calc_value,
Params((ParamOption(dynamic),)))
option = ConvertDynOptionDescription(**self.attrib)
elif not self.is_leader:
option = OptionDescription(**self.attrib)
if not self.option_name:
self.populate_attrib()
self.parse_children()
self.option_name = self.storage.get_name(self.path)
object_name = self.get_object_name()
attrib = self.get_attrib(self.attrib) + ', children=[' + ', '.join([child.get() for child in self.children]) + ']'
self.storage.text.append(f'{self.option_name} = {object_name}({attrib})')
self.populate_informations()
return self.option_name
def populate_attrib(self):
for key, value in self.elt.attrib.items():
if key == 'help':
self.informations[key] = value
elif key == 'dynamic':
dynamic = self.storage.get(value).get()
self.attrib['suffixes'] = f"Calculation(func.calc_value, Params((ParamOption({dynamic}))))"
else:
option = Leadership(**self.attrib)
except Exception as err:
print(self.attrib)
raise CreoleLoaderError(_('cannot create optiondescription "{}": {}').format(self.attrib['name'], err))
for key, value in self.informations.items():
option.impl_set_information(key, value)
self.option = option
return self.option
self.attrib[key] = value
def parse_children(self):
self.attrib['properties'] = ''
for child in self.elt:
if child.tag == 'property':
self.populate_properties(child)
if not self.attrib['properties']:
del self.attrib['properties']
def get_object_name(self):
if 'suffixes' in self.attrib:
return 'ConvertDynOptionDescription'
elif not self.is_leader:
return 'OptionDescription'
return 'Leadership'
def load(xmlroot: str,
dtd_path: str,
funcs_path: str):
tiramisu_objects = PopulateTiramisuObjects()
tiramisu_objects.parse_dtd(dtd_path)
tiramisu_objects.make_tiramisu_objects(xmlroot,
funcs_path)
return tiramisu_objects.storage.paths['.'].get()
tiramisu_objects = PopulateTiramisuObjects(xmlroot,
funcs_path,
)
return tiramisu_objects.get_text()

27
src/rougail/objspace.py
View File

@ -28,10 +28,11 @@ from lxml.etree import Element, SubElement # pylint: disable=E0611
from .i18n import _
from .xmlreflector import XMLReflector, HIGH_COMPATIBILITY
from .annotator import ERASED_ATTRIBUTES, VARIABLE_NAMESPACE, ServiceAnnotator, SpaceAnnotator
from .annotator import ERASED_ATTRIBUTES, ServiceAnnotator, SpaceAnnotator
from .utils import normalize_family
from .error import CreoleOperationError, SpaceObjShallNotBeUpdated, CreoleDictConsistencyError
from .error import OperationError, SpaceObjShallNotBeUpdated, DictConsistencyError
from .path import Path
from .config import variable_namespace
# CreoleObjSpace's elements like 'family' or 'follower', that shall be forced to the Redefinable type
FORCE_REDEFINABLES = ('family', 'follower', 'service', 'disknod', 'variables')
@ -178,7 +179,7 @@ class CreoleObjSpace:
continue
if child.tag == 'family':
if child.attrib['name'] in family_names:
raise CreoleDictConsistencyError(_('Family {} is set several times').format(child.attrib['name']))
raise DictConsistencyError(_('Family {} is set several times').format(child.attrib['name']))
family_names.append(child.attrib['name'])
if child.tag == 'variables':
child.attrib['name'] = namespace
@ -296,12 +297,12 @@ class CreoleObjSpace:
)
elif exists is False:
raise SpaceObjShallNotBeUpdated()
raise CreoleDictConsistencyError(_(f'Already present in another XML file, {name} cannot be re-created'))
raise DictConsistencyError(_(f'Already present in another XML file, {name} cannot be re-created'))
redefine = self.convert_boolean(subspace.get('redefine', False))
exists = self.convert_boolean(subspace.get('exists', False))
if redefine is False or exists is True:
return getattr(self, child.tag)()
raise CreoleDictConsistencyError(_(f'Redefined object: {name} does not exist yet'))
raise DictConsistencyError(_(f'Redefined object: {name} does not exist yet'))
def create_tree_structure(self,
space,
@ -325,12 +326,12 @@ class CreoleObjSpace:
elif isinstance(variableobj, self.UnRedefinable):
setattr(space, child.tag, [])
elif not isinstance(variableobj, self.Atom): # pragma: no cover
raise CreoleOperationError(_("Creole object {} "
raise OperationError(_("Creole object {} "
"has a wrong type").format(type(variableobj)))
def is_already_exists(self, name, space, child, namespace):
if isinstance(space, self.family): # pylint: disable=E1101
if namespace != VARIABLE_NAMESPACE:
if namespace != variable_namespace:
name = space.path + '.' + name
return self.paths.path_is_defined(name)
if child.tag == 'family':
@ -363,14 +364,14 @@ class CreoleObjSpace:
else:
norm_name = name
return getattr(family, variable.tag)[norm_name]
if namespace == VARIABLE_NAMESPACE:
if namespace == variable_namespace:
path = name
else:
path = family.path + '.' + name
old_family_name = self.paths.get_variable_family_name(path)
if normalize_family(family.name) == old_family_name:
return getattr(family, variable.tag)[name]
old_family = self.space.variables[VARIABLE_NAMESPACE].family[old_family_name] # pylint: disable=E1101
old_family = self.space.variables[variable_namespace].family[old_family_name] # pylint: disable=E1101
variable_obj = old_family.variable[name]
del old_family.variable[name]
if 'variable' not in vars(family):
@ -452,7 +453,7 @@ class CreoleObjSpace:
# UNREDEFINABLE concerns only 'variable' node so we can fix name
# to child.attrib['name']
name = child.attrib['name']
raise CreoleDictConsistencyError(_(f'cannot redefine attribute {attr} for variable {name}'))
raise DictConsistencyError(_(f'cannot redefine attribute {attr} for variable {name}'))
if attr in self.booleans_attributs:
val = self.convert_boolean(val)
if not (attr == 'name' and getattr(variableobj, 'name', None) != None):
@ -504,7 +505,7 @@ class CreoleObjSpace:
document.attrib.get('dynamic') != None,
variableobj)
if child.attrib.get('redefine', 'False') == 'True':
if namespace == VARIABLE_NAMESPACE:
if namespace == variable_namespace:
self.redefine_variables.append(child.attrib['name'])
else:
self.redefine_variables.append(namespace + '.' + family_name + '.' +
@ -512,7 +513,7 @@ class CreoleObjSpace:
elif child.tag == 'family':
family_name = normalize_family(child.attrib['name'])
if namespace != VARIABLE_NAMESPACE:
if namespace != variable_namespace:
family_name = namespace + '.' + family_name
self.paths.add_family(namespace,
family_name,
@ -590,7 +591,7 @@ class CreoleObjSpace:
def _xml_export(self,
node,
space,
node_name=VARIABLE_NAMESPACE,
node_name=variable_namespace,
):
for name in self.get_attributes(space):
subspace = getattr(space, name)

28
src/rougail/path.py
View File

@ -1,7 +1,7 @@
from .i18n import _
from .utils import normalize_family
from .error import CreoleOperationError, CreoleDictConsistencyError
from .annotator import VARIABLE_NAMESPACE
from .error import OperationError, DictConsistencyError
from .config import variable_namespace
class Path:
@ -30,13 +30,13 @@ class Path:
current_namespace: str,
) -> str: # pylint: disable=C0111
if current_namespace is None: # pragma: no cover
raise CreoleOperationError('current_namespace must not be None')
raise OperationError('current_namespace must not be None')
dico = self.families[normalize_family(name,
check_name=False,
allow_dot=True,
)]
if dico['namespace'] != VARIABLE_NAMESPACE and current_namespace != dico['namespace']:
raise CreoleDictConsistencyError(_('A family located in the {} namespace '
if dico['namespace'] != variable_namespace and current_namespace != dico['namespace']:
raise DictConsistencyError(_('A family located in the {} namespace '
'shall not be used in the {} namespace').format(
dico['namespace'], current_namespace))
path = dico['name']
@ -48,7 +48,7 @@ class Path:
name: str,
) -> 'Family': # pylint: disable=C0111
if name not in self.families:
raise CreoleDictConsistencyError(_('unknown family {}').format(name))
raise DictConsistencyError(_('unknown family {}').format(name))
dico = self.families[name]
return dico['variableobj']
@ -59,7 +59,7 @@ class Path:
name: str,
leader_name: str,
) -> None: # pylint: disable=C0111
if namespace != VARIABLE_NAMESPACE:
if namespace != variable_namespace:
# need rebuild path and move object in new path
old_path = namespace + '.' + leader_family_name + '.' + name
dico = self._get_variable(old_path)
@ -74,7 +74,7 @@ class Path:
name = new_path
dico = self._get_variable(name)
if dico['leader'] != None:
raise CreoleDictConsistencyError(_('Already defined leader {} for variable'
raise DictConsistencyError(_('Already defined leader {} for variable'
' {}'.format(dico['leader'], name)))
dico['leader'] = leader_name
@ -89,7 +89,7 @@ class Path:
is_dynamic: bool,
variableobj,
) -> str: # pylint: disable=C0111
if namespace == VARIABLE_NAMESPACE or '.' in name:
if namespace == variable_namespace or '.' in name:
varname = name
else:
varname = '.'.join([namespace, family, name])
@ -127,7 +127,7 @@ class Path:
with_suffix: bool=False,
) -> str: # pylint: disable=C0111
if current_namespace is None: # pragma: no cover
raise CreoleOperationError('current_namespace must not be None')
raise OperationError('current_namespace must not be None')
if with_suffix:
dico, suffix = self._get_variable(name,
with_suffix=True,
@ -135,8 +135,8 @@ class Path:
else:
dico = self._get_variable(name)
if not allow_source:
if dico['namespace'] not in [VARIABLE_NAMESPACE, 'services'] and current_namespace != dico['namespace']:
raise CreoleDictConsistencyError(_('A variable located in the {} namespace '
if dico['namespace'] not in [variable_namespace, 'services'] and current_namespace != dico['namespace']:
raise DictConsistencyError(_('A variable located in the {} namespace '
'shall not be used in the {} namespace').format(
dico['namespace'], current_namespace))
if '.' in dico['name']:
@ -161,13 +161,13 @@ class Path:
with_suffix: bool=False,
) -> str:
if name not in self.variables:
if name.startswith(f'{VARIABLE_NAMESPACE}.'):
if name.startswith(f'{variable_namespace}.'):
name = name.split('.')[-1]
if name not in self.variables:
for var_name, variable in self.variables.items():
if variable['is_dynamic'] and name.startswith(var_name):
return variable, name[len(var_name):]
raise CreoleDictConsistencyError(_('unknown option {}').format(name))
raise DictConsistencyError(_('unknown option {}').format(name))
if with_suffix:
return self.variables[name], None
return self.variables[name]

5
src/rougail/template.py
View File

@ -18,8 +18,7 @@ from Cheetah.NameMapper import NotFound as CheetahNotFound
from tiramisu import Config
from tiramisu.error import PropertiesOptionError
from .annotator import VARIABLE_NAMESPACE
from .config import patch_dir
from .config import patch_dir, variable_namespace
from .error import FileNotFound, TemplateError
from .i18n import _
from .utils import normalize_family
@ -373,7 +372,7 @@ class CreoleTemplateEngine:
"""
for option in await self.config.option.list(type='all'):
namespace = await option.option.name()
if namespace == VARIABLE_NAMESPACE:
if namespace == variable_namespace:
await self.load_eole_variables_rougail(option)
else:
families = await self.load_eole_variables(namespace,

10
src/rougail/tiramisu.py Normal file
View File

@ -0,0 +1,10 @@
from tiramisu import DynOptionDescription
from .utils import normalize_family
class ConvertDynOptionDescription(DynOptionDescription):
def convert_suffix_to_path(self, suffix):
if not isinstance(suffix, str):
suffix = str(suffix)
return normalize_family(suffix,
check_name=False)

4
src/rougail/xmlreflector.py
View File

@ -6,7 +6,7 @@ from os import listdir
from lxml.etree import DTD, parse, tostring # , XMLParser
from .i18n import _
from .error import CreoleDictConsistencyError
from .error import DictConsistencyError
HIGH_COMPATIBILITY = True
@ -38,7 +38,7 @@ class XMLReflector(object):
# document = parse(BytesIO(xmlfile), XMLParser(remove_blank_text=True))
document = parse(xmlfile)
if not self.dtd.validate(document):
raise CreoleDictConsistencyError(_("not a valid xml file: {}").format(xmlfile))
raise DictConsistencyError(_("not a valid xml file: {}").format(xmlfile))
return document.getroot()
def load_xml_from_folders(self, xmlfolders):

0
tests/flattener_dicos/00empty/__init__.py Normal file
View File

0
tests/flattener_dicos/00empty/tiramisu/__init__.py Normal file
View File

7
tests/flattener_dicos/00empty/tiramisu/base.py Normal file
View File

@ -0,0 +1,7 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_2 = OptionDescription(doc='tata', name='tata', children=[])
option_1 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_autofreeze/__init__.py Normal file
View File

0
tests/flattener_dicos/00load_autofreeze/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/00load_autofreeze/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_autofreezeexpert/__init__.py Normal file
View File

0
tests/flattener_dicos/00load_autofreezeexpert/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/00load_autofreezeexpert/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'expert', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_autosave/__init__.py Normal file
View File

0
tests/flattener_dicos/00load_autosave/tiramisu/__init__.py Normal file
View File

8
tests/flattener_dicos/00load_autosave/tiramisu/base.py Normal file
View File

@ -0,0 +1,8 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'mandatory', 'basic']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_autosaveexpert/__init__.py Normal file
View File

0
tests/flattener_dicos/00load_autosaveexpert/tiramisu/__init__.py Normal file
View File

8
tests/flattener_dicos/00load_autosaveexpert/tiramisu/base.py Normal file
View File

@ -0,0 +1,8 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['expert']), children=[option_3])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_comment/__init__.py Normal file
View File

0
tests/flattener_dicos/00load_comment/tiramisu/__init__.py Normal file
View File

8
tests/flattener_dicos/00load_comment/tiramisu/base.py Normal file
View File

@ -0,0 +1,8 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_notype/__init__.py Normal file
View File

2
tests/flattener_dicos/00load_notype/result/00-base.xml
View File

@ -16,7 +16,7 @@
<variable doc="without_type" multi="False" name="without_type" type="string">
<property>mandatory</property>
<property>normal</property>
<value>non</value>
<value type="string">non</value>
</variable>
</family>
</family>

0
tests/flattener_dicos/00load_notype/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/00load_notype/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_4 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='without_type', multi=False, name='without_type', default='non')
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_save/__init__.py Normal file
View File

0
tests/flattener_dicos/00load_save/tiramisu/__init__.py Normal file
View File

8
tests/flattener_dicos/00load_save/tiramisu/base.py Normal file
View File

@ -0,0 +1,8 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/00load_subfolder/__init__.py Normal file
View File

0
tests/flattener_dicos/00load_subfolder/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/00load_subfolder/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01auto_base/__init__.py Normal file
View File

2
tests/flattener_dicos/01auto_base/result/00-base.xml
View File

@ -12,7 +12,7 @@
<property>mandatory</property>
<property>normal</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
<param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01auto_base/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01auto_base/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01auto_withoutparam/__init__.py Normal file
View File

0
tests/flattener_dicos/01auto_withoutparam/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01auto_withoutparam/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((), kwargs={})), values=('oui', 'non'))
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01base_multi/__init__.py Normal file
View File

0
tests/flattener_dicos/01base_multi/tiramisu/__init__.py Normal file
View File

8
tests/flattener_dicos/01base_multi/tiramisu/base.py Normal file
View File

@ -0,0 +1,8 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Redefine description', multi=True, name='mode_conteneur_actif', default=['non'], default_multi='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01fill_autofreeze/__init__.py Normal file
View File

2
tests/flattener_dicos/01fill_autofreeze/result/00-base.xml
View File

@ -12,7 +12,7 @@
<property>basic</property>
<property expected="oui" inverse="True" source="rougail.general.module_instancie" type="calculation">auto_frozen</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
<param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01fill_autofreeze/tiramisu/__init__.py Normal file
View File

10
tests/flattener_dicos/01fill_autofreeze/tiramisu/base.py Normal file
View File

@ -0,0 +1,10 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_5, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3, option_4, option_5])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01fill_autosave/__init__.py Normal file
View File

2
tests/flattener_dicos/01fill_autosave/result/00-base.xml
View File

@ -10,7 +10,7 @@
<property>mandatory</property>
<property>basic</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
<param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01fill_autosave/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01fill_autosave/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'mandatory', 'basic']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01fill_base/__init__.py Normal file
View File

2
tests/flattener_dicos/01fill_base/result/00-base.xml
View File

@ -12,7 +12,7 @@
<property>mandatory</property>
<property>normal</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
<param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01fill_base/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01fill_base/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01fill_baseaccent/__init__.py Normal file
View File

2
tests/flattener_dicos/01fill_baseaccent/result/00-base.xml
View File

@ -12,7 +12,7 @@
<property>mandatory</property>
<property>normal</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
<param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01fill_baseaccent/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01fill_baseaccent/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
option_2 = OptionDescription(doc='Général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01fill_mandatory/__init__.py Normal file
View File

2
tests/flattener_dicos/01fill_mandatory/result/00-base.xml
View File

@ -7,7 +7,7 @@
<property>mandatory</property>
<property>expert</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
<param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01fill_mandatory/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01fill_mandatory/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_3 = DomainnameOption(type='domainname', allow_ip=True, allow_without_dot=True, properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01fill_number/__init__.py Normal file
View File

2
tests/flattener_dicos/01fill_number/result/00-base.xml
View File

@ -10,7 +10,7 @@
<property>mandatory</property>
<property>normal</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="number">3</param>
<param type="number">3</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01fill_number/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01fill_number/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = IntOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamValue(3)), kwargs={})))
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01fill_optional/__init__.py Normal file
View File

2
tests/flattener_dicos/01fill_optional/result/00-base.xml
View File

@ -12,7 +12,7 @@
<property>mandatory</property>
<property>normal</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
<param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
</value>
</variable>
<variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">

0
tests/flattener_dicos/01fill_optional/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01fill_optional/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01separator_base/__init__.py Normal file
View File

0
tests/flattener_dicos/01separator_base/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01separator_base/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_3.impl_set_information("separator", "Établissement")
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/01separator_neverhidden/__init__.py Normal file
View File

0
tests/flattener_dicos/01separator_neverhidden/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/01separator_neverhidden/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_3.impl_set_information("separator", "Établissement")
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/10autosave_hidden/__init__.py Normal file
View File

2
tests/flattener_dicos/10autosave_hidden/result/00-base.xml
View File

@ -20,7 +20,7 @@
<property>mandatory</property>
<property>basic</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="string">oui</param>
<param type="string">oui</param>
</value>
</variable>
</family>

0
tests/flattener_dicos/10autosave_hidden/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/10autosave_hidden/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_4 = StrOption(properties=frozenset(['force_store_value', 'frozen', 'hidden', 'mandatory', 'basic']), doc='autosave variable', multi=False, name='autosavevar', default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/10autosave_hidden_frozenifin/__init__.py Normal file
View File

2
tests/flattener_dicos/10autosave_hidden_frozenifin/result/00-base.xml
View File

@ -21,7 +21,7 @@
<property expected="oui" inverse="False" source="rougail.general.mode_conteneur_actif" type="calculation">hidden</property>
<property expected="oui" inverse="False" source="rougail.general.mode_conteneur_actif" type="calculation">force_default_on_freeze</property>
<value name="calc_val" type="calculation">
<param transitive="False" type="string">oui</param>
<param type="string">oui</param>
</value>
</variable>
</family>

0
tests/flattener_dicos/10autosave_hidden_frozenifin/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/10autosave_hidden_frozenifin/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
option_4 = StrOption(properties=frozenset(['force_store_value', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='autosave variable', multi=False, name='autosavevar', default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/10check_base/__init__.py Normal file
View File

2
tests/flattener_dicos/10check_base/result/00-base.xml
View File

@ -6,7 +6,7 @@
<variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
<property>mandatory</property>
<property>normal</property>
<value>b</value>
<value type="string">b</value>
</variable>
<variable doc="No change" multi="False" name="int" type="number">
<check name="valid_entier" warnings_only="False">

0
tests/flattener_dicos/10check_base/tiramisu/__init__.py Normal file
View File

9
tests/flattener_dicos/10check_base/tiramisu/base.py Normal file
View File

@ -0,0 +1,9 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='b')
option_4 = IntOption(properties=frozenset(['normal']), validators=[Calculation(func.valid_entier, Params((ParamSelfOption()), kwargs={'mini': ParamValue("0"), 'maxi': ParamValue("100")}), warnings_only=False)], doc='No change', multi=False, name='int')
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/10check_option/__init__.py Normal file
View File

6
tests/flattener_dicos/10check_option/result/00-base.xml
View File

@ -6,17 +6,17 @@
<variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
<property>mandatory</property>
<property>normal</property>
<value>b</value>
<value type="string">b</value>
</variable>
<variable doc="No change" multi="False" name="int2" type="number">
<property>mandatory</property>
<property>normal</property>
<value>100</value>
<value type="number">100</value>
</variable>
<variable doc="No change" multi="False" name="int" type="number">
<check name="valid_entier" warnings_only="False">
<param name="mini" type="string">0</param>
<param name="maxi" type="variable">rougail.general.int2</param>
<param name="maxi" notraisepropertyerror="False" type="variable">rougail.general.int2</param>
</check>
<property>normal</property>
</variable>

0
tests/flattener_dicos/10check_option/tiramisu/__init__.py Normal file
View File

10
tests/flattener_dicos/10check_option/tiramisu/base.py Normal file
View File

@ -0,0 +1,10 @@
from tiramisu import *
from rougail.tiramisu import ConvertDynOptionDescription
import imp
func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='b')
option_4 = IntOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='int2', default=100)
option_5 = IntOption(properties=frozenset(['normal']), validators=[Calculation(func.valid_entier, Params((ParamSelfOption()), kwargs={'mini': ParamValue("0"), 'maxi': ParamOption(option_4, notraisepropertyerror=False, todict=False)}), warnings_only=False)], doc='No change', multi=False, name='int')
option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

0
tests/flattener_dicos/10check_optional/__init__.py Normal file
View File

4
tests/flattener_dicos/10check_optional/result/00-base.xml
View File

@ -6,11 +6,11 @@
<variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
<property>mandatory</property>
<property>normal</property>
<value>b</value>
<value type="string">b</value>
</variable>
<variable doc="No change" multi="False" name="int" type="number">
<check name="valid_not_equal" warnings_only="False">
<param type="variable">rougail.general.int2</param>
<param notraisepropertyerror="False" type="variable">rougail.general.int2</param>
</check>
<property>normal</property>
</variable>

Some files were not shown because too many files have changed in this diff Show More