FIXME

@@ -1,5 +0,0 @@
-default avec quote
-values avec quote
-informations avec quote (help)
-param value avec quote
-suffix avec quote dans param ?

src/rougail/annotator/__init__.py

@@ -1,11 +1,10 @@
 """Annotate dictionaries
 """
 from .group import GroupAnnotator
-from .service import ServiceAnnotator
+from .service import ServiceAnnotator, ERASED_ATTRIBUTES
 from .variable import VariableAnnotator, CONVERT_OPTION
 from .check import CheckAnnotator
-from .value import ValueAnnotator
+from .condition import Conditionnnotator
-from .condition import ConditionAnnotator
 from .fill import FillAnnotator
 from .family import FamilyAnnotator, modes
 from .property import PropertyAnnotator
@@ -21,13 +20,12 @@ class SpaceAnnotator:  # pylint: disable=R0903
         CheckAnnotator(objectspace,
                        eosfunc_file,
                        )
-        ConditionAnnotator(objectspace)
+        Conditionnnotator(objectspace)
         FillAnnotator(objectspace,
                       eosfunc_file,
                       )
         FamilyAnnotator(objectspace)
         PropertyAnnotator(objectspace)
-        ValueAnnotator(objectspace)
 
 
-__all__ = ('SpaceAnnotator', 'CONVERT_OPTION', 'modes')
+__all__ = ('SpaceAnnotator', 'ERASED_ATTRIBUTES', 'CONVERT_OPTION', 'modes')

src/rougail/annotator/check.py

@@ -129,7 +129,7 @@ class CheckAnnotator:
         # value for choice's variable is mandatory
         variable.mandatory = True
         # build choice
-        variable.values = []
+        variable.choice = []
         variable_type = variable.type
         variable.type = 'choice'
 
@@ -182,7 +182,7 @@ class CheckAnnotator:
             choice = self.objectspace.choice(variable.xmlfiles)
             choice.name = value
             choice.type = param_type
-            variable.values.append(choice)
+            variable.choice.append(choice)
 
         if has_variable:
             return None
@@ -223,7 +223,7 @@ class CheckAnnotator:
                         msg = _(f'unknown parameter "{param.name}" in check "valid_entier" '
                                 f'for variable "{check.target.name}" in {xmlfiles}')
                         raise DictConsistencyError(msg, 19)
-                continue
+            else:
-            if not hasattr(check.target, 'validators'):
+                if not hasattr(check.target, 'check'):
-                check.target.validators = []
+                    check.target.check = []
-            check.target.validators.append(check)
+                check.target.check.append(check)

src/rougail/annotator/condition.py

@@ -10,7 +10,7 @@ from ..config import Config
 FREEZE_AUTOFREEZE_VARIABLE = 'module_instancie'
 
 
-class ConditionAnnotator:
+class Conditionnnotator:
     """Annotate condition
     """
     def __init__(self,
@@ -290,6 +290,6 @@ class ConditionAnnotator:
         prop.source = condition.source
         prop.expected = text
         prop.name = action
-        if not hasattr(obj, 'properties'):
+        if not hasattr(obj, 'property'):
-            obj.properties = []
+            obj.property = []
-        obj.properties.append(prop)
+        obj.property.append(prop)

src/rougail/annotator/family.py

@@ -2,8 +2,6 @@
 """
 from ..i18n import _
 from ..error import DictConsistencyError
-from ..utils import normalize_family
-from .variable import RENAME_ATTIBUTES
 
 
 #mode order is important
@@ -36,30 +34,13 @@ class FamilyAnnotator:
                  objectspace,
                  ):
         self.objectspace = objectspace
-        if not hasattr(self.objectspace.space, 'variables'):
+        if hasattr(self.objectspace.space, 'variables'):
-            return
-        self.family_names()
             self.remove_empty_families()
             self.change_variable_mode()
             self.change_family_mode()
             self.dynamic_families()
-        self.convert_help()
 
-    def family_names(self) -> None:
+    def remove_empty_families(self):
-        """Set doc, path, ... to family
-        """
-        for families in self.objectspace.space.variables.values():
-            families.doc = families.name
-            families.path = families.name
-            for family in families.family.values():
-                if not hasattr(family, 'description'):
-                    family.description = family.name
-                for key, value in RENAME_ATTIBUTES.items():
-                    setattr(family, value, getattr(family, key))
-                    setattr(family, key, None)
-                family.name = normalize_family(family.name)
-
-    def remove_empty_families(self) -> None:
         """Remove all families without any variable
         """
         for families in self.objectspace.space.variables.values():
@@ -188,21 +169,9 @@ class FamilyAnnotator:
             for family in families.family.values():
                 if 'dynamic' not in vars(family):
                     continue
-                family.suffixes = self.objectspace.paths.get_variable(family.dynamic)
+                family.dynamic = self.objectspace.paths.get_variable(family.dynamic)
-                del family.dynamic
+                if not family.dynamic.multi:
-                if not family.suffixes.multi:
                     xmlfiles = self.objectspace.display_xmlfiles(family.xmlfiles)
                     msg = _(f'dynamic family "{family.name}" must be linked '
                             f'to multi variable in {xmlfiles}')
                     raise DictConsistencyError(msg, 16)
-
-    def convert_help(self):
-        """Convert variable help
-        """
-        for families in self.objectspace.space.variables.values():
-            for family in families.family.values():
-                if hasattr(family, 'help'):
-                    if not hasattr(family, 'information'):
-                        family.information = self.objectspace.information(family.xmlfiles)
-                    family.information.help = family.help
-                    del family.help

src/rougail/annotator/property.py

@@ -26,27 +26,25 @@ class PropertyAnnotator:
                          ) -> None:
         """convert properties
         """
-        if not hasattr(variable, 'properties'):
+        properties = []
-            variable.properties = []
-
         for prop in PROPERTIES:
             if hasattr(variable, prop):
                 if getattr(variable, prop) is True:
                     for subprop in CONVERT_PROPERTIES.get(prop, [prop]):
-                        variable.properties.append(subprop)
+                        properties.append(subprop)
                 setattr(variable, prop, None)
         if hasattr(variable, 'mode') and variable.mode:
-            variable.properties.append(variable.mode)
+            properties.append(variable.mode)
             variable.mode = None
-        if 'force_store_value' in variable.properties and \
+        if 'force_store_value' in properties and \
-                'force_default_on_freeze' in variable.properties:  # pragma: no cover
+                'force_default_on_freeze' in properties:  # pragma: no cover
             # should not appened
             xmlfiles = self.objectspace.display_xmlfiles(variable.xmlfiles)
             msg = _('cannot have auto_freeze or auto_store with the hidden '
                     f'variable "{variable.name}" in {xmlfiles}')
             raise DictConsistencyError(msg, 50)
-        if not variable.properties:
+        if properties:
-            del variable.properties
+            variable.properties = set(properties)
 
     def convert_services(self) -> None:
         """convert services

src/rougail/annotator/service.py

@@ -11,7 +11,7 @@ from ..error import DictConsistencyError
 ERASED_ATTRIBUTES = ('redefine', 'exists', 'fallback', 'optional', 'remove_check', 'namespace',
                      'remove_condition', 'path', 'instance_mode', 'index', 'is_in_leadership',
                      'level', 'remove_fill', 'xmlfiles', 'type', 'reflector_name',
-                     'reflector_object', 'manage')
+                     'reflector_object',)
 
 
 KEY_TYPE = {'variable': 'symlink',
@@ -50,12 +50,14 @@ class ServiceAnnotator:
         self.objectspace.space.services.name = 'services'
         self.objectspace.space.services.doc = 'services'
         self.objectspace.space.services.path = 'services'
-        for service_name, service in self.objectspace.space.services.service.items():
+        families = {}
-            service.information = self.objectspace.information(service.xmlfiles)
+        for service_name in self.objectspace.space.services.service.keys():
-            service.information.manage = service.manage
+            service = self.objectspace.space.services.service[service_name]
-            service.manage = None
+            new_service = self.objectspace.service(service.xmlfiles)
-            for elttype, values in dict(vars(service)).items():
+            new_service.path = f'services.{service_name}'
+            for elttype, values in vars(service).items():
                 if not isinstance(values, (dict, list)) or elttype in ERASED_ATTRIBUTES:
+                    setattr(new_service, elttype, values)
                     continue
                 eltname = elttype + 's'
                 path = '.'.join(['services', normalize_family(service_name), eltname])
@@ -70,8 +72,10 @@ class ServiceAnnotator:
                                                           values,
                                                           path,
                                                           )
-                setattr(service, elttype, family)
+                setattr(new_service, elttype, family)
-            service.doc = service.name
+            new_service.doc = new_service.name
+            families[service_name] = new_service
+        self.objectspace.space.services.service = families
 
     def make_group_from_elts(self,
                              service_name,
@@ -183,7 +187,10 @@ class ServiceAnnotator:
             variable.multi = None
         else:
             variable.doc = key
-            variable.default = value
+            val = self.objectspace.value(xmlfiles)
+            val.type = type_
+            val.name = value
+            variable.value = [val]
             variable.namespace = 'services'
         self.objectspace.paths.add_variable('services',
                                             path,

src/rougail/annotator/value.py

@@ -1,51 +0,0 @@
-"""Annotate value
-"""
-
-class ValueAnnotator:  # pylint: disable=R0903
-    """Annotate value
-    """
-    def __init__(self,
-                 objectspace,
-                 ) -> None:
-        if not hasattr(objectspace.space, 'variables'):
-            return
-        self.objectspace = objectspace
-        self.convert_value()
-
-    def convert_value(self) -> None:
-        """convert value
-        """
-        for families in self.objectspace.space.variables.values():
-            for family in families.family.values():
-                for variable in family.variable.values():
-                    if isinstance(variable, self.objectspace.leadership):
-                        variable_type = 'leader'
-                        for follower in variable.variable:
-                            self._convert_value(follower,
-                                                variable_type,
-                                                )
-                            variable_type = 'follower'
-                    else:
-                        self._convert_value(variable)
-
-    @staticmethod
-    def _convert_value(variable,
-                       variable_type: str=None,
-                       ) -> None:
-        if not hasattr(variable, 'value'):
-            return
-        if variable.value[0].type == 'calculation':
-            variable.default = variable.value[0]
-        else:
-            if variable.multi:
-                if variable_type != 'follower':
-                    variable.default = [value.name for value in variable.value]
-                if variable_type != 'leader':
-                    if variable.multi == 'submulti':
-                        variable.default_multi = [value.name for value in variable.value]
-                    else:
-                        #FIXME 0 ou -1 ?
-                        variable.default_multi = variable.value[-1].name
-            else:
-                variable.default = variable.value[0].name
-        del variable.value

src/rougail/annotator/variable.py

@@ -1,5 +1,6 @@
 """Annotate variable
 """
+from ..utils import normalize_family
 
 
 CONVERT_OPTION = {'number': dict(opttype="IntOption", func=int),
@@ -53,13 +54,20 @@ class VariableAnnotator:  # pylint: disable=R0903
         self.objectspace = objectspace
         self.convert_variable()
         self.convert_test()
-        self.convert_help()
 
     def convert_variable(self):
         """convert variable
         """
         for families in self.objectspace.space.variables.values():
+            families.doc = families.name
+            families.path = families.name
             for family in families.family.values():
+                if not hasattr(family, 'description'):
+                    family.description = family.name
+                for key, value in RENAME_ATTIBUTES.items():
+                    setattr(family, value, getattr(family, key))
+                    setattr(family, key, None)
+                family.name = normalize_family(family.name)
                 if not hasattr(family, 'variable'):
                     continue
                 for variable in family.variable.values():
@@ -154,10 +162,10 @@ class VariableAnnotator:  # pylint: disable=R0903
     def _convert_test(self,
                       variable,
                       ) -> None:
-        if not hasattr(variable, 'information'):
-            variable.information = self.objectspace.information(variable.xmlfiles)
         if hasattr(variable, 'test'):
-            if variable.test:
+            if not variable.test:
+                del variable.test
+                return
             values = variable.test.split('|')
             new_values = []
             for value in values:
@@ -166,25 +174,4 @@ class VariableAnnotator:  # pylint: disable=R0903
                 else:
                     value = CONVERT_OPTION.get(variable.type, {}).get('func', str)(value)
                 new_values.append(value)
-                variable.information.test = tuple(new_values)
+            variable.test = tuple(new_values)
-            del variable.test
-
-    def convert_help(self):
-        """Convert variable help
-        """
-        for families in self.objectspace.space.variables.values():
-            for family in families.family.values():
-                if not hasattr(family, 'variable'):
-                    continue
-                for variable in family.variable.values():
-                    if isinstance(variable, self.objectspace.leadership):
-                        for follower in variable.variable:
-                            self._convert_help(follower)
-                    else:
-                        self._convert_help(variable)
-
-    @staticmethod
-    def _convert_help(variable) -> None:
-        if hasattr(variable, 'help'):
-            variable.information.help = variable.help
-            del variable.help

src/rougail/objspace.py

@@ -17,7 +17,7 @@ FORCE_UNREDEFINABLES = ('value',)
 # RougailObjSpace's elements that shall not be modify
 UNREDEFINABLE = ('multi', 'type')
 # RougailObjSpace's elements that did not created automaticly
-FORCE_ELEMENTS = ('choice', 'property_', 'leadership', 'information')
+FORCE_ELEMENTS = ('choice', 'property_', 'leadership')
 # XML text are convert has name
 FORCED_TEXT_ELTS_AS_NAME = ('choice', 'property', 'value', 'target')
 

src/rougail/rougail.py

@@ -65,7 +65,7 @@ class Rougail:
     def save(self) -> str:
         """Return tiramisu object declaration as a string
         """
-        tiramisu_objects = TiramisuReflector(self.rougailobjspace,
+        tiramisu_objects = TiramisuReflector(self.rougailobjspace.space,
                                              self.funcs_path,
                                              )
         return tiramisu_objects.get_text() + '\n'

src/rougail/tiramisureflector.py

@@ -2,11 +2,13 @@
 flattened XML specific
 """
 from .config import Config
-from .annotator import CONVERT_OPTION
+from .annotator import ERASED_ATTRIBUTES, CONVERT_OPTION
-from .objspace import RootRougailObject
+#from .objspace import UnRedefinable, Redefinable, Atom
 
 
 FUNC_TO_DICT = []
+FORCE_INFORMATIONS = ['help', 'test', 'manage']
+ATTRIBUTES_ORDER = ('name', 'doc', 'default', 'multi')
 
 
 class Root():  # pylint: disable=R0903
@@ -15,19 +17,11 @@ class Root():  # pylint: disable=R0903
     path = '.'
 
 
-class BaseElt:  # pylint: disable=R0903
-    """Base element
-    """
-    name = 'baseoption'
-    doc = 'baseoption'
-    path = '.'
-
-
 class TiramisuReflector:
     """Convert object to tiramisu representation
     """
     def __init__(self,
-                 objectspace,
+                 space,
                  funcs_path,
                  ):
         self.index = 0
@@ -46,37 +40,63 @@ class TiramisuReflector:
                      "    from tiramisu import *",
                      "from rougail.tiramisu import ConvertDynOptionDescription",
                      ]
-        self.objectspace = objectspace
+        self.make_tiramisu_objects(space)
-        self.make_tiramisu_objects()
 
-    def make_tiramisu_objects(self) -> None:
+    def make_tiramisu_objects(self,
+                              space,
+                              ):
         """make tiramisu objects
         """
         baseelt = BaseElt()
         self.set_name(baseelt)
         basefamily = Family(baseelt,
                             self.text,
-                            self.objectspace,
                             )
-        for elt in self.reorder_family():
+        for elt in self.reorder_family(space):
-            self.populate_family(basefamily,
+            self.iter_family(basefamily,
                              elt,
                              )
         # parse object
         baseelt.reflector_object.get()  # pylint: disable=E1101
 
-    def reorder_family(self):
+    @staticmethod
+    def reorder_family(space):
         """variable_namespace family has to be loaded before any other family
         because `extra` family could use `variable_namespace` variables.
         """
-        if hasattr(self.objectspace.space, 'variables'):
+        if hasattr(space, 'variables'):
-            if Config['variable_namespace'] in self.objectspace.space.variables:
+            if Config['variable_namespace'] in space.variables:
-                yield self.objectspace.space.variables[Config['variable_namespace']]
+                yield space.variables[Config['variable_namespace']]
-            for elt, value in self.objectspace.space.variables.items():
+            for elt, value in space.variables.items():
                 if elt != Config['variable_namespace']:
                     yield value
-        if hasattr(self.objectspace.space, 'services'):
+        if hasattr(space, 'services'):
-            yield self.objectspace.space.services
+            yield space.services
+
+    def get_attributes(self, space):  # pylint: disable=R0201
+        """Get attributes
+        """
+        for attr in dir(space):
+            if not attr.startswith('_') and attr not in ERASED_ATTRIBUTES:
+                yield attr
+
+    def iter_family(self,
+                    family,
+                    child,
+                    ):
+        """Iter each family
+        """
+        tag = child.__class__.__name__
+        if tag == 'Variable':
+            function = self.populate_variable
+        elif tag == 'Property':
+            # property already imported with family
+            return
+        else:
+            function = self.populate_family
+        function(family,
+                 child,
+                 )
 
     def populate_family(self,
                         parent_family,
@@ -87,32 +107,46 @@ class TiramisuReflector:
         self.set_name(elt)
         family = Family(elt,
                         self.text,
-                        self.objectspace,
                         )
         parent_family.add(family)
-        for children in vars(elt).values():
+        for children in self.get_children(elt):
-            if isinstance(children, self.objectspace.family):
+            for child in children:
-                self.populate_family(family,
+                self.iter_family(family,
-                                     children,
+                                 child,
                                  )
-                continue
+
+    def get_children(self,
+                     space,
+                     ):
+        """Get children
+        """
+        for tag in self.get_attributes(space):
+            children = getattr(space, tag)
+            if children.__class__.__name__ == 'Family':
+                children = [children]
             if isinstance(children, dict):
                 children = list(children.values())
             if isinstance(children, list):
-                for child in children:
+                yield children
-                    if isinstance(child, self.objectspace.property_) or \
+
-                            not isinstance(child, RootRougailObject):
+    def populate_variable(self,
-                        continue
+                          family,
-                    if isinstance(child, self.objectspace.variable):
+                          elt,
-                        self.set_name(child)
+                          ):
-                        family.add(Variable(child,
+        """Populate variable
-                                            self.text,
+        """
-                                            self.objectspace,
+        if family.is_leadership:
-                                            ))
+            is_leader = elt.name == family.elt.variable[0].name
+            is_follower = not is_leader
         else:
-                        self.populate_family(family,
+            is_leader = False
-                                             child,
+            is_follower = False
-                                             )
+        self.set_name(elt)
+        family.add(Variable(elt,
+                            self.text,
+                            is_follower,
+                            is_leader,
+                            ))
 
     def set_name(self,
                  elt,
@@ -128,85 +162,100 @@ class TiramisuReflector:
         return '\n'.join(self.text)
 
 
+class BaseElt:  # pylint: disable=R0903
+    """Base element
+    """
+    name = 'baseoption'
+    doc = 'baseoption'
+    path = '.'
+
+
 class Common:
     """Common function for variable and family
     """
     def __init__(self,
                  elt,
                  text,
-                 objectspace,
                  ):
         self.elt = elt
         self.option_name = None
+        self.attrib = {}
+        self.informations = {}
         self.text = text
-        self.objectspace = objectspace
         self.elt.reflector_object = self
-        self.object_type = None
 
-    def get(self):
+    def populate_properties(self, child):
-        """Get tiramisu's object
-        """
-        if self.option_name is None:
-            self.option_name = self.elt.reflector_name
-            self.populate_attrib()
-            self.populate_informations()
-        return self.option_name
-
-    def populate_attrib(self):
-        """Populate attributes
-        """
-        keys = {'name': self.convert_str(self.elt.name)}
-        if hasattr(self.elt, 'doc'):
-            keys['doc'] = self.convert_str(self.elt.doc)
-        self._populate_attrib(keys)
-        if hasattr(self.elt, 'properties'):
-            keys['properties'] = self.properties_to_string(self.elt.properties)
-        attrib = ', '.join([f'{key}={value}' for key, value in keys.items()])
-        self.text.append(f'{self.option_name} = {self.object_type}({attrib})')
-
-    def _populate_attrib(self,
-                         keys: dict,
-                         ) -> None:  # pragma: no cover
-        raise NotImplementedError()
-
-    @staticmethod
-    def convert_str(value):
-        """convert string
-        """
-        return "'" + value.replace("'", "\\\'") + "'"
-
-    def properties_to_string(self,
-                             values: list,
-                             ) -> None:
-        """Change properties to string
-        """
-        properties = [f"'{property_}'" for property_ in values if isinstance(property_, str)]
-        calc_properties = [self.calc_properties(property_) for property_ in values \
-                if isinstance(property_, self.objectspace.property_)]
-        return 'frozenset({' + ', '.join(sorted(properties) + calc_properties) + '})'
-
-    @staticmethod
-    def calc_properties(child) -> str:
         """Populate properties
         """
+        assert child.type == 'calculation'
+        action = f"ParamValue('{child.name}')"
         option_name = child.source.reflector_object.get()
         kwargs = (f"'condition': ParamOption({option_name}, todict=True), "
                   f"'expected': ParamValue('{child.expected}')")
         if child.inverse:
             kwargs += ", 'reverse_condition': ParamValue(True)"
-        return f"Calculation(calc_value, Params(ParamValue('{child.name}'), kwargs={{{kwargs}}}))"
+        prop = 'Calculation(calc_value, Params(' + action + ', kwargs={' + kwargs + '}))'
+        if self.attrib['properties']:
+            self.attrib['properties'] += ', '
+        self.attrib['properties'] += prop
+
+    def properties_to_string(self):
+        """Change properties to string
+        """
+        if not self.attrib['properties']:
+            self.attrib['properties'] = ''
+        else:
+            self.attrib['properties'] = "'" + "', '".join(sorted(self.attrib['properties'])) + "'"
+
+    def get_attrib(self):
+        """Get attributes
+        """
+        ret_list = []
+        for key, value in self.attrib.items():
+            if value is None:
+                continue
+            if key == 'properties':
+                if not self.attrib[key]:
+                    continue
+                value = "frozenset({" + self.attrib[key] + "})"
+            elif key in ['default', 'multi', 'suffixes', 'validators', 'values']:
+                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):
         """Populate Tiramisu's informations
         """
-        if not hasattr(self.elt, 'information'):
+        for key, value in self.informations.items():
-            return
-        for key, value in vars(self.elt.information).items():
-            if key == 'xmlfiles':
-                continue
             if isinstance(value, str):
-                value = self.convert_str(value)
+                value = '"' + value.replace('"', '\"') + '"'
-            self.text.append(f"{self.option_name}.impl_set_information('{key}', {value})")
+            self.text.append(f'{self.option_name}.impl_set_information("{key}", {value})')
+
+    def get_attributes(self, space):  # pylint: disable=R0201
+        """Get attributes
+        """
+        attributes = dir(space)
+        for attr in ATTRIBUTES_ORDER:
+            if attr in attributes:
+                yield attr
+        for attr in dir(space):
+            if attr not in ATTRIBUTES_ORDER:
+                if not attr.startswith('_') and attr not in ERASED_ATTRIBUTES:
+                    value = getattr(space, attr)
+                    if not isinstance(value, (list, dict)) and \
+                            not value.__class__.__name__ == 'Family':
+                        yield attr
+
+    @staticmethod
+    def get_children(space):
+        """Get children
+        """
+        for attr in dir(space):
+            if not attr.startswith('_') and attr not in ERASED_ATTRIBUTES:
+                if isinstance(getattr(space, attr), list):
+                    yield attr, getattr(space, attr)
 
 
 class Variable(Common):
@@ -215,41 +264,100 @@ class Variable(Common):
     def __init__(self,
                  elt,
                  text,
-                 objectspace,
+                 is_follower,
+                 is_leader,
                  ):
-        super().__init__(elt, text, objectspace)
+        super().__init__(elt, text)
-        self.object_type = CONVERT_OPTION[elt.type]['opttype']
+        self.is_leader = is_leader
+        self.is_follower = is_follower
+        convert_option = CONVERT_OPTION[elt.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'] = []
 
-    def _populate_attrib(self,
+    def get(self):
-                         keys: dict,
+        """Get tiramisu's object
-                         ):
+        """
-        if hasattr(self.elt, 'opt'):
+        if self.option_name is None:
-            keys['opt'] = self.elt.opt.reflector_object.get()
+            self.populate_attrib()
-        if hasattr(self.elt, 'values'):
+            if self.object_type == 'SymLinkOption':
-            values = self.elt.values
+                self.attrib['opt'] = self.attrib['opt'].reflector_object.get()
-            if values[0].type == 'calculation':
-                value = values[0].name.reflector_object.get()
-                keys['values'] = f"Calculation(func.calc_value, Params((ParamOption({value}))))"
             else:
-                keys['values'] = str(tuple([val.name for val in values]))
+                self.parse_children()
-        if hasattr(self.elt, 'multi') and self.elt.multi:
+            attrib = self.get_attrib()
-            keys['multi'] = self.elt.multi
+            self.option_name = self.elt.reflector_name
-        for key in ['default', 'default_multi']:
+            self.text.append(f'{self.option_name} = {self.object_type}({attrib})')
-            if hasattr(self.elt, key) and getattr(self.elt, key) is not None:
+            self.populate_informations()
+        return self.option_name
+
+    def populate_attrib(self):
+        """Populate attributes
+        """
+        for key in self.get_attributes(self.elt):
             value = getattr(self.elt, key)
-                if isinstance(value, str):
+            if key in FORCE_INFORMATIONS:
-                    value = self.convert_str(value)
+                self.informations[key] = value
-                elif isinstance(value, self.objectspace.value):
+            else:
-                    value = self.calculation_value(value, [])
+                self.attrib[key] = value
-                keys[key] = value
+
-        if hasattr(self.elt, 'validators'):
+    def parse_children(self):
-            keys['validators'] = '[' + ', '.join([self.calculation_value(val,
+        """Parse children
-                                    ['ParamSelfOption()']) for val in self.elt.validators]) + ']'
+        """
-        for key in ['min_number', 'max_number']:
+        if 'default' not in self.attrib or self.attrib['multi']:
-            if hasattr(self.elt, key):
+            self.attrib['default'] = []
-                keys[key] = getattr(self.elt, key)
+        if self.attrib['multi'] == 'submulti' and self.is_follower:
-        for key, value in CONVERT_OPTION[self.elt.type].get('initkwargs', {}).items():
+            self.attrib['default_multi'] = []
-            keys[key] = value
+        choices = []
+        self.properties_to_string()
+        for tag, children in self.get_children(self.elt):
+            for child in children:
+                self.parse_child(tag,
+                                 child,
+                                 choices,
+                                 )
+        if choices:
+            self.attrib['values'] = str(tuple(choices))
+        if not 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 not self.attrib['validators']:
+            del self.attrib['validators']
+        else:
+            self.attrib['validators'] = '[' + ', '.join(self.attrib['validators']) + ']'
+
+    def parse_child(self,
+                    tag,
+                    child,
+                    choices,
+                    ) -> None:
+        """Parse child
+        """
+        if tag == 'property':
+            self.populate_properties(child)
+        elif tag == 'value':
+            self.populate_value(child)
+        elif tag == 'check':
+            validator = self.calculation_value(child, ['ParamSelfOption()'])
+            self.attrib['validators'].append(validator)
+        elif tag == 'choice':
+            self.calculate_choice(child,
+                                  choices,
+                                  )
+
+    def calculate_choice(self,
+                         child,
+                         choices: list,
+                         ) -> None:
+        """Calculating choice
+        """
+        if child.type == 'calculation':
+            value = child.name.reflector_object.get()
+            self.attrib['values'] = f"Calculation(func.calc_value, Params((ParamOption({value}))))"
+        else:
+            choices.append(child.name)
 
     def calculation_value(self,
                           child,
@@ -267,10 +375,8 @@ class Variable(Common):
                     args.append(str(value))
                 else:
                     kwargs.append(f"'{param.name}': " + value)
-        ret = f'Calculation(func.{function}, Params((' + ', '.join(args) + ')'
+        ret = f"Calculation(func.{function}, Params((" + ', '.join(args) + \
-        if kwargs:
+                "), kwargs=" + "{" + ', '.join(kwargs) + "})"
-            ret += ', kwargs={' + ', '.join(kwargs) + '}'
-        ret += ')'
         if hasattr(child, 'warnings_only'):
             ret += f', warnings_only={child.warnings_only}'
         return ret + ')'
@@ -282,32 +388,55 @@ class Variable(Common):
         """Populate variable parameters
         """
         if param.type == 'string':
-            value = param.text
+            return f'ParamValue("{param.text}")'
-            if value is not None:
-                value = self.convert_str(value)
-            return f"ParamValue({value})"
         if param.type == 'number':
             return f'ParamValue({param.text})'
         if param.type == 'variable':
-            return self.build_param(param, function)
+            value = {'option': param.text,
+                     'notraisepropertyerror': param.notraisepropertyerror,
+                     'todict': function in FUNC_TO_DICT,
+                     }
+            if hasattr(param, 'suffix'):
+                value['suffix'] = param.suffix
+                value['family'] = param.family
+            return self.build_param(value)
         if param.type == 'information':
             return f'ParamInformation("{param.text}", None)'
         if param.type == 'suffix':
             return 'ParamSuffix()'
         return ''  # pragma: no cover
 
+    def populate_value(self,
+                       child,
+                       ):
+        """Populate variable's values
+        """
+        if child.type == 'calculation':
+            self.attrib['default'] = self.calculation_value(child, [])
+        else:
+            value = child.name
+            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, float)) or value is None:
+                self.attrib['default'].append(value)
+            else:
+                self.attrib['default'].append("'" + value + "'")
+
     @staticmethod
-    def build_param(param,
+    def build_param(param) -> str:
-                    function: str,
-                    ) -> str:
         """build variable parameters
         """
-        option_name = param.text.reflector_object.get()
+        option_name = param['option'].reflector_object.get()
-        todict = function in FUNC_TO_DICT
+        ends = f"notraisepropertyerror={param['notraisepropertyerror']}, todict={param['todict']})"
-        ends = f"notraisepropertyerror={param.notraisepropertyerror}, todict={todict})"
+        if 'suffix' in param:
-        if hasattr(param, 'suffix'):
+            family_name = param['family'].reflector_name
-            family_name = param.family.reflector_name
+            return f"ParamDynOption({option_name}, '{param['suffix']}', {family_name}, {ends}"
-            return f"ParamDynOption({option_name}, '{param.suffix}', {family_name}, {ends}"
         return f"ParamOption({option_name}, {ends}"
 
 
@@ -317,15 +446,9 @@ class Family(Common):
     def __init__(self,
                  elt,
                  text,
-                 objectspace,
                  ):
-        super().__init__(elt, text, objectspace)
+        super().__init__(elt, text)
-        if hasattr(self.elt, 'suffixes'):
+        self.is_leadership = self.elt.__class__.__name__ == 'Leadership'
-            self.object_type = 'ConvertDynOptionDescription'
-        elif isinstance(self.elt, self.objectspace.leadership):
-            self.object_type = 'Leadership'
-        else:
-            self.object_type = 'OptionDescription'
         self.children = []
 
     def add(self, child):
@@ -333,10 +456,48 @@ class Family(Common):
         """
         self.children.append(child)
 
-    def _populate_attrib(self,
+    def get(self):
-                         keys: list,
+        """Get tiramisu's object
-                         ) -> None:
+        """
-        if hasattr(self.elt, 'suffixes'):
+        if not self.option_name:
-            dyn = self.elt.suffixes.reflector_object.get()
+            self.populate_attrib()
-            keys['suffixes'] = f"Calculation(func.calc_value, Params((ParamOption({dyn}))))"
+            self.parse_children()
-        keys['children'] = '[' + ', '.join([child.get() for child in self.children]) + ']'
+            self.option_name = self.elt.reflector_name
+            object_name = self.get_object_name()
+            attrib = self.get_attrib() + \
+                    ', children=[' + ', '.join([child.get() for child in self.children]) + ']'
+            self.text.append(f'{self.option_name} = {object_name}({attrib})')
+            self.populate_informations()
+        return self.option_name
+
+    def populate_attrib(self):
+        """parse a populate attributes
+        """
+        for key in self.get_attributes(self.elt):
+            value = getattr(self.elt, key)
+            if key in FORCE_INFORMATIONS:
+                self.informations[key] = value
+            elif key == 'dynamic':
+                dynamic = value.reflector_object.get()
+                self.attrib['suffixes'] = \
+                        f"Calculation(func.calc_value, Params((ParamOption({dynamic}))))"
+            else:
+                self.attrib[key] = value
+
+    def parse_children(self):
+        """parse current children
+        """
+        if 'properties' in self.attrib:
+            self.properties_to_string()
+            if hasattr(self.elt, 'property'):
+                for child in self.elt.property:
+                    self.populate_properties(child)
+
+    def get_object_name(self):
+        """Get family object's name
+        """
+        if 'suffixes' in self.attrib:
+            return 'ConvertDynOptionDescription'
+        if self.is_leadership:
+            return 'Leadership'
+        return 'OptionDescription'

tests/dictionaries/00empty/tiramisu/base.py

@@ -13,6 +13,6 @@ except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
 option_2 = OptionDescription(name='tata', doc='tata', children=[])
-option_2.impl_set_information('manage', True)
+option_2.impl_set_information("manage", True)
-option_1 = OptionDescription(name='services', doc='services', children=[option_2], properties=frozenset({'hidden'}))
+option_1 = OptionDescription(name='services', doc='services', properties=frozenset({'hidden'}), children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_autofreeze/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'auto_freeze', 'basic', 'force_store_value', 'mandatory', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_3 = StrOption(properties=frozenset({'auto_freeze', 'basic', 'force_store_value', 'mandatory', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'basic'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_autofreezeexpert/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'auto_freeze', 'expert', 'force_store_value', 'mandatory', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_3 = StrOption(properties=frozenset({'auto_freeze', 'expert', 'force_store_value', 'mandatory', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_autosave/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'basic', 'force_store_value', 'mandatory'}))
+option_3 = StrOption(properties=frozenset({'basic', 'force_store_value', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'basic'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_autosaveexpert/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'force_store_value', 'mandatory'}))
+option_3 = StrOption(properties=frozenset({'expert', 'force_store_value', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'expert'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'expert'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_comment/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_notype/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='without_type', doc='without_type', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='without_type', doc='without_type', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_save/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/00load_subfolder/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01auto_autofreeze/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamValue('oui')))), properties=frozenset({'auto_freeze', 'basic', 'force_store_value', 'frozen', 'hidden', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_4 = StrOption(properties=frozenset({'auto_freeze', 'basic', 'force_store_value', 'frozen', 'hidden', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01auto_base/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01auto_withoutparam/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params(())), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((), kwargs={})))
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01base_file_include/tiramisu/base.py

@@ -12,19 +12,19 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='Description', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='Description', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
-option_8 = StrOption(name='group', doc='group', default='root')
+option_8 = StrOption(name='group', doc='group', multi=False, default='root')
-option_9 = StrOption(name='mode', doc='mode', default='0644')
+option_9 = StrOption(name='mode', doc='mode', multi=False, default='0644')
-option_10 = StrOption(name='name', doc='name', default='/etc/file')
+option_10 = StrOption(name='name', doc='name', multi=False, default='/etc/file')
-option_11 = StrOption(name='owner', doc='owner', default='root')
+option_11 = StrOption(name='owner', doc='owner', multi=False, default='root')
-option_12 = StrOption(name='source', doc='source', default='file')
+option_12 = StrOption(name='source', doc='source', multi=False, default='file')
-option_13 = BoolOption(name='templating', doc='templating', default=True)
+option_13 = BoolOption(name='templating', doc='templating', multi=False, default=True)
-option_14 = BoolOption(name='activate', doc='activate', default=True)
+option_14 = BoolOption(name='activate', doc='activate', multi=False, default=True)
 option_7 = OptionDescription(name='file', doc='file', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
 option_6 = OptionDescription(name='files', doc='files', children=[option_7])
 option_5 = OptionDescription(name='test', doc='test', children=[option_6])
-option_5.impl_set_information('manage', True)
+option_5.impl_set_information("manage", True)
-option_4 = OptionDescription(name='services', doc='services', children=[option_5], properties=frozenset({'hidden'}))
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset({'hidden'}), children=[option_5])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])

tests/dictionaries/01base_file_patch/tiramisu/base.py

@@ -12,19 +12,19 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='Description', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='Description', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
-option_8 = StrOption(name='group', doc='group', default='root')
+option_8 = StrOption(name='group', doc='group', multi=False, default='root')
-option_9 = StrOption(name='mode', doc='mode', default='0644')
+option_9 = StrOption(name='mode', doc='mode', multi=False, default='0644')
-option_10 = StrOption(name='name', doc='name', default='/etc/file')
+option_10 = StrOption(name='name', doc='name', multi=False, default='/etc/file')
-option_11 = StrOption(name='owner', doc='owner', default='root')
+option_11 = StrOption(name='owner', doc='owner', multi=False, default='root')
-option_12 = StrOption(name='source', doc='source', default='file')
+option_12 = StrOption(name='source', doc='source', multi=False, default='file')
-option_13 = BoolOption(name='templating', doc='templating', default=True)
+option_13 = BoolOption(name='templating', doc='templating', multi=False, default=True)
-option_14 = BoolOption(name='activate', doc='activate', default=True)
+option_14 = BoolOption(name='activate', doc='activate', multi=False, default=True)
 option_7 = OptionDescription(name='file', doc='file', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
 option_6 = OptionDescription(name='files', doc='files', children=[option_7])
 option_5 = OptionDescription(name='test', doc='test', children=[option_6])
-option_5.impl_set_information('manage', True)
+option_5.impl_set_information("manage", True)
-option_4 = OptionDescription(name='services', doc='services', children=[option_5], properties=frozenset({'hidden'}))
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset({'hidden'}), children=[option_5])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])

tests/dictionaries/01base_file_utfchar/tiramisu/base.py

@@ -12,19 +12,19 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='Description', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='Description', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
-option_8 = StrOption(name='group', doc='group', default='root')
+option_8 = StrOption(name='group', doc='group', multi=False, default='root')
-option_9 = StrOption(name='mode', doc='mode', default='0644')
+option_9 = StrOption(name='mode', doc='mode', multi=False, default='0644')
-option_10 = StrOption(name='name', doc='name', default='/etc/systemd-makefs@dev-disk-by\\x2dpartlabel')
+option_10 = StrOption(name='name', doc='name', multi=False, default='/etc/systemd-makefs@dev-disk-by\\x2dpartlabel')
-option_11 = StrOption(name='owner', doc='owner', default='root')
+option_11 = StrOption(name='owner', doc='owner', multi=False, default='root')
-option_12 = StrOption(name='source', doc='source', default='systemd-makefs@dev-disk-by\\x2dpartlabel')
+option_12 = StrOption(name='source', doc='source', multi=False, default='systemd-makefs@dev-disk-by\\x2dpartlabel')
-option_13 = BoolOption(name='templating', doc='templating', default=True)
+option_13 = BoolOption(name='templating', doc='templating', multi=False, default=True)
-option_14 = BoolOption(name='activate', doc='activate', default=True)
+option_14 = BoolOption(name='activate', doc='activate', multi=False, default=True)
 option_7 = OptionDescription(name='systemd_makefs@dev_disk_by\\x2dpartlabel', doc='systemd-makefs@dev-disk-by\\x2dpartlabel', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
 option_6 = OptionDescription(name='files', doc='files', children=[option_7])
 option_5 = OptionDescription(name='test', doc='test', children=[option_6])
-option_5.impl_set_information('manage', True)
+option_5.impl_set_information("manage", True)
-option_4 = OptionDescription(name='services', doc='services', children=[option_5], properties=frozenset({'hidden'}))
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset({'hidden'}), children=[option_5])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])

tests/dictionaries/01base_float/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = FloatOption(name='float', doc='Description', default=0.527, properties=frozenset({'mandatory', 'normal'}))
+option_3 = FloatOption(properties=frozenset({'mandatory', 'normal'}), name='float', doc='Description', multi=False, default=0.527)
-option_4 = FloatOption(name='float_multi', doc='Description', multi=True, default=[0.527], default_multi=0.527, properties=frozenset({'mandatory', 'normal'}))
+option_4 = FloatOption(properties=frozenset({'mandatory', 'normal'}), name='float_multi', doc='Description', multi=True, default=[0.527], default_multi=0.527)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01base_multi/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='Redefine description', multi=True, default=['non'], default_multi='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='Redefine description', multi=True, default=['non'], default_multi='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01base_var_name_same_family/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='general', doc='description', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='general', doc='description', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01family_description/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='Other description', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='Other description', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_autofreeze/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)))), properties=frozenset({'auto_freeze', 'basic', 'force_store_value', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_5, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_3 = StrOption(properties=frozenset({'auto_freeze', 'basic', 'force_store_value', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_5, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_autosave/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)))), properties=frozenset({'basic', 'force_store_value'}))
+option_3 = StrOption(properties=frozenset({'basic', 'force_store_value'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_base/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_3 = StrOption(properties=frozenset({'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_baseaccent/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_mandatory/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)))), properties=frozenset({'expert', 'mandatory'}))
+option_3 = StrOption(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_number/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = IntOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamValue(3)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_3 = IntOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamValue(3)), kwargs={})))
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_only_optional/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params(())), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((), kwargs={})))
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01fill_optional/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01hidden_if_in_autofreeze/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamValue('oui')))), properties=frozenset({'auto_freeze', 'basic', 'force_store_value', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_4 = StrOption(properties=frozenset({'auto_freeze', 'basic', 'force_store_value', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01test/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
-option_3.impl_set_information('test', ('test',))
+option_3.impl_set_information("test", ('test',))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01test_multi/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
-option_3.impl_set_information('test', ('test1', 'test2'))
+option_3.impl_set_information("test", ('test1', 'test2'))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01test_multi_none/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
-option_3.impl_set_information('test', (None, 'test1', 'test2'))
+option_3.impl_set_information("test", (None, 'test1', 'test2'))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01test_redefine/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
-option_3.impl_set_information('test', ('test1',))
+option_3.impl_set_information("test", ('test1',))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/01test_redefine_remove/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/02autosave_hidden_frozenifin/tiramisu/base.py

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

tests/dictionaries/10autosave_hidden/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='autosavevar', doc='autosave variable', default=Calculation(func.calc_val, Params((ParamValue('oui')))), properties=frozenset({'basic', 'force_store_value', 'frozen', 'hidden'}))
+option_4 = StrOption(properties=frozenset({'basic', 'force_store_value', 'frozen', 'hidden'}), name='autosavevar', doc='autosave variable', multi=False, default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
-option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'basic'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_base/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
-option_4 = IntOption(name='int', doc='No change', min_number=0, max_number=100, properties=frozenset({'normal'}))
+option_4 = IntOption(properties=frozenset({'normal'}), name='int', doc='No change', multi=False, max_number=100, min_number=0)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_no_param/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
-option_4 = IntOption(name='int', doc='No change', validators=[Calculation(func.valid_lower, Params((ParamSelfOption())), warnings_only=False)], properties=frozenset({'normal'}))
+option_4 = IntOption(properties=frozenset({'normal'}), validators=[Calculation(func.valid_lower, Params((ParamSelfOption()), kwargs={}), warnings_only=False)], name='int', doc='No change', multi=False)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_option/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
-option_4 = IntOption(name='int2', doc='No change', default=100, properties=frozenset({'mandatory', 'normal'}))
+option_4 = IntOption(properties=frozenset({'mandatory', 'normal'}), name='int2', doc='No change', multi=False, default=100)
-option_5 = IntOption(name='int', doc='No change', validators=[Calculation(func.valid_lower, Params((ParamSelfOption()), kwargs={'mini': ParamValue('0'), 'maxi': ParamOption(option_4, notraisepropertyerror=False, todict=False)}), warnings_only=False)], properties=frozenset({'normal'}))
+option_5 = IntOption(properties=frozenset({'normal'}), validators=[Calculation(func.valid_lower, Params((ParamSelfOption()), kwargs={'mini': ParamValue("0"), 'maxi': ParamOption(option_4, notraisepropertyerror=False, todict=False)}), warnings_only=False)], name='int', doc='No change', multi=False)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_optional/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
-option_5 = IntOption(name='int2', doc='No change', properties=frozenset({'normal'}))
+option_5 = IntOption(properties=frozenset({'normal'}), name='int2', doc='No change', multi=False)
-option_4 = IntOption(name='int', doc='No change', validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False))), warnings_only=False)], properties=frozenset({'normal'}))
+option_4 = IntOption(properties=frozenset({'normal'}), validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], name='int', doc='No change', multi=False)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_valid_differ/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False))), warnings_only=False)], properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_valid_differ_add/tiramisu/base.py

@@ -12,10 +12,10 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_6 = StrOption(name='mode_conteneur_actif3', doc='No change', default='oui', validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False))), warnings_only=False), Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False))), warnings_only=False), Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False))), warnings_only=False)], properties=frozenset({'mandatory', 'normal'}))
+option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False), Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False), Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], name='mode_conteneur_actif3', doc='No change', multi=False, default='oui')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5, option_6], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5, option_6])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_valid_differ_removecheck/tiramisu/base.py

@@ -12,10 +12,10 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
-option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_6 = StrOption(name='mode_conteneur_actif3', doc='No change', default='oui', validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False))), warnings_only=False), Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False))), warnings_only=False)], properties=frozenset({'mandatory', 'normal'}))
+option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), validators=[Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False), Calculation(func.valid_differ, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], name='mode_conteneur_actif3', doc='No change', multi=False, default='oui')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5, option_6], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5, option_6])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_valid_in_network/tiramisu/base.py

@@ -12,10 +12,10 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
-option_4 = IPOption(name='adresse_ip_eth0', doc='Adresse IP de la carte', private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}))
+option_4 = IPOption(private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}), name='adresse_ip_eth0', doc='Adresse IP de la carte', multi=False)
-option_5 = NetmaskOption(name='adresse_netmask_eth0', doc='Masque de sous réseau de la carte', properties=frozenset({'basic', 'mandatory'}))
+option_5 = NetmaskOption(properties=frozenset({'basic', 'mandatory'}), name='adresse_netmask_eth0', doc='Masque de sous réseau de la carte', multi=False)
-option_6 = IPOption(name='adresse_ip', doc='IP', validators=[Calculation(func.valid_in_network, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False), ParamOption(option_5, notraisepropertyerror=False, todict=False))), warnings_only=True)], private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}))
+option_6 = IPOption(private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}), validators=[Calculation(func.valid_in_network, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False), ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=True)], name='adresse_ip', doc='IP', multi=False)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5, option_6], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5, option_6])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_valid_in_network_cidr/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
-option_4 = IPOption(name='adresse_ip_eth0', doc='Adresse IP de la carte', cidr=True, properties=frozenset({'basic', 'mandatory'}))
+option_4 = IPOption(cidr=True, properties=frozenset({'basic', 'mandatory'}), name='adresse_ip_eth0', doc='Adresse IP de la carte', multi=False)
-option_5 = IPOption(name='adresse_ip', doc='IP', validators=[Calculation(func.valid_in_network, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False))), warnings_only=True)], private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}))
+option_5 = IPOption(private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}), validators=[Calculation(func.valid_in_network, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=True)], name='adresse_ip', doc='IP', multi=False)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10check_valid_ipnetmask/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
-option_4 = IPOption(name='adresse_ip_eth0', doc='Adresse IP de la carte', private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}))
+option_4 = IPOption(private_only=True, warnings_only=True, properties=frozenset({'basic', 'mandatory'}), name='adresse_ip_eth0', doc='Adresse IP de la carte', multi=False)
-option_5 = NetmaskOption(name='adresse_netmask_eth0', doc='Masque de sous réseau de la carte', validators=[Calculation(func.valid_ipnetmask, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False))), warnings_only=True)], properties=frozenset({'basic', 'mandatory'}))
+option_5 = NetmaskOption(properties=frozenset({'basic', 'mandatory'}), validators=[Calculation(func.valid_ipnetmask, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=True)], name='adresse_netmask_eth0', doc='Masque de sous réseau de la carte', multi=False)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10fill_information/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamInformation("test_information", None)))), properties=frozenset({'normal'}))
+option_3 = StrOption(properties=frozenset({'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamInformation("test_information", None)), kwargs={})))
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_append/tiramisu/base.py

@@ -12,13 +12,13 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_9 = StrOption(name='follower3', doc='follower3', multi=True, properties=frozenset({'normal'}))
+option_9 = StrOption(properties=frozenset({'normal'}), name='follower3', doc='follower3', multi=True)
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8, option_9], properties=frozenset({'normal'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8, option_9])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_append_hidden/tiramisu/base.py

@@ -12,13 +12,13 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
-option_6 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({'force_default_on_freeze', 'frozen'}))
+option_6 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen'}), name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}))
+option_7 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}))
+option_8 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_9 = StrOption(name='follower3', doc='follower3', multi=True, properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}))
+option_9 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}), name='follower3', doc='follower3', multi=True)
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8, option_9], properties=frozenset({'hidden', 'normal'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'hidden', 'normal'}), children=[option_6, option_7, option_8, option_9])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_append_name/tiramisu/base.py

@@ -12,13 +12,13 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_9 = StrOption(name='follower3', doc='follower3', multi=True, properties=frozenset({'normal'}))
+option_9 = StrOption(properties=frozenset({'normal'}), name='follower3', doc='follower3', multi=True)
-option_5 = Leadership(name='leadership', doc='leadership', children=[option_6, option_7, option_8, option_9], properties=frozenset({'normal'}))
+option_5 = Leadership(name='leadership', doc='leadership', properties=frozenset({'normal'}), children=[option_6, option_7, option_8, option_9])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_auto/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_6 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_7 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_8 = StrOption(name='follower3', doc='follower3', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_5, notraisepropertyerror=False, todict=False)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_8 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='follower3', doc='follower3', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7, option_8], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7, option_8])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_autoleader/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_6 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_5, notraisepropertyerror=False, todict=False)))), properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}))
+option_7 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_autoleader_expert/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
+option_3 = StrOption(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
-option_6 = StrOption(name='leader', doc='leader', multi=True, default=Calculation(func.calc_list, Params((), kwargs={'valeur': ParamValue('valfill')})))
+option_6 = StrOption(name='leader', doc='leader', multi=True, default=Calculation(func.calc_list, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'expert'}))
+option_7 = StrOption(properties=frozenset({'expert'}), name='follower1', doc='follower1', multi=True)
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'expert'}))
+option_8 = StrOption(properties=frozenset({'expert'}), name='follower2', doc='follower2', multi=True)
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'expert'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'expert'}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'expert'}))
+option_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'expert'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_autosaveexpert/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)))), properties=frozenset({'expert'}))
+option_7 = StrOption(properties=frozenset({'expert'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_familyaccent/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_leader_hidden/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
+option_3 = StrOption(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
-option_6 = StrOption(name='leader', doc='leader', multi=True, default=Calculation(func.calc_list, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'force_default_on_freeze', 'frozen'}))
+option_6 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen'}), name='leader', doc='leader', multi=True, default=Calculation(func.calc_list, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}))
+option_7 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}), name='follower1', doc='follower1', multi=True)
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}))
+option_8 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}), name='follower2', doc='follower2', multi=True)
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'hidden', 'normal'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'hidden', 'normal'}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_leader_hidden_if_in/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
+option_3 = StrOption(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
-option_6 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_6 = StrOption(properties=frozenset({Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_7 = StrOption(properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), name='follower1', doc='follower1', multi=True)
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_8 = StrOption(properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), name='follower2', doc='follower2', multi=True)
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_leader_hidden_if_in_name/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
+option_3 = StrOption(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
-option_6 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_6 = StrOption(properties=frozenset({Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_7 = StrOption(properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), name='follower1', doc='follower1', multi=True)
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_8 = StrOption(properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), name='follower2', doc='follower2', multi=True)
-option_5 = Leadership(name='other', doc='other', children=[option_6, option_7, option_8], properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}))
+option_5 = Leadership(name='other', doc='other', properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('non')}))}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_leadermandatory/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({'mandatory'}))
+option_5 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True)
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'basic'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'basic'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_mandatory/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'mandatory', 'normal'}))
+option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_mandatoryfollower/tiramisu/base.py

@@ -12,10 +12,10 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
 option_5 = NetmaskOption(name='nut_monitor_netmask', doc='Masque de l\'IP du réseau de l\'esclave', multi=True)
-option_6 = NetworkOption(name='nut_monitor_host', doc='Adresse IP du réseau de l\'esclave', multi=True, properties=frozenset({'mandatory', 'normal'}))
+option_6 = NetworkOption(properties=frozenset({'mandatory', 'normal'}), name='nut_monitor_host', doc='Adresse IP du réseau de l\'esclave', multi=True)
-option_4 = Leadership(name='nut_monitor_netmask', doc='Masque de l\'IP du réseau de l\'esclave', children=[option_5, option_6], properties=frozenset({'normal'}))
+option_4 = Leadership(name='nut_monitor_netmask', doc='Masque de l\'IP du réseau de l\'esclave', properties=frozenset({'normal'}), children=[option_5, option_6])
-option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10leadership_multi/tiramisu/base.py

@@ -12,16 +12,16 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
 option_10 = StrOption(name='leader1', doc='leader', multi=True)
-option_11 = StrOption(name='follower11', doc='follower1', multi=True, properties=frozenset({'normal'}))
+option_11 = StrOption(properties=frozenset({'normal'}), name='follower11', doc='follower1', multi=True)
-option_12 = StrOption(name='follower21', doc='follower2', multi=True, properties=frozenset({'normal'}))
+option_12 = StrOption(properties=frozenset({'normal'}), name='follower21', doc='follower2', multi=True)
-option_9 = Leadership(name='leader1', doc='leader', children=[option_10, option_11, option_12], properties=frozenset({'normal'}))
+option_9 = Leadership(name='leader1', doc='leader', properties=frozenset({'normal'}), children=[option_10, option_11, option_12])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5, option_9], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5, option_9])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabled_if_in/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_4 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_5 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabled_if_in_none/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('None')}))}))
+option_4 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('None')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('None')}))}))
+option_5 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('None')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabled_if_inaccent_family/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
-option_7 = StrOption(name='mode_conteneur_actif3', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_7 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif3', doc='No change', multi=False, default='non')
-option_6 = OptionDescription(name='general2', doc='Général2', children=[option_7], properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_6 = OptionDescription(name='general2', doc='Général2', properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), children=[option_7])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_6])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabled_if_not_in_fallback/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabled_if_not_in_fallback_force/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabledifin_fallback/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'disabled', 'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'disabled', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabledifin_fallback_force/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_disabledifin_whithouttype/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_emptyvalue/tiramisu/base.py

@@ -12,8 +12,8 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', properties=frozenset({'normal'}))
+option_3 = StrOption(properties=frozenset({'normal'}), name='mode_conteneur_actif', doc='No change', multi=False)
-option_4 = StrOption(name='mode_conteneur_actif2', doc='No change', properties=frozenset({'normal'}))
+option_4 = StrOption(properties=frozenset({'normal'}), name='mode_conteneur_actif2', doc='No change', multi=False)
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_frozenifin/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_frozenifin_auto/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamValue('non')))), properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}))
+option_4 = StrOption(properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamValue("non")), kwargs={})))
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_frozenifin_multiparam/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'mandatory', 'normal'}))
+option_3 = ChoiceOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_frozenifin_noexist/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'mandatory', 'normal'}))
+option_3 = ChoiceOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_5 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_frozenifnotin/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_frozenifnotin_noexist/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'mandatory', 'normal'}))
+option_3 = ChoiceOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_5 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_hidden_if_family/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
-option_7 = StrOption(name='mode_conteneur_actif3', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}))
+option_7 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), 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')}))}), name='mode_conteneur_actif3', doc='No change', multi=False, default='non')
-option_6 = OptionDescription(name='general2', doc='Général2', children=[option_7], properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_6 = OptionDescription(name='general2', doc='Général2', properties=frozenset({'normal', Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), children=[option_7])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_6])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership_default_multi/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non')
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, default_multi='value', properties=frozenset({'mandatory', 'normal'}))
+option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower1', doc='follower1', multi=True, default_multi='value')
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True)
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership_default_submulti/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non')
-option_5 = StrOption(name='leader', doc='leader', multi=True, default=['leader'], properties=frozenset({'mandatory'}))
+option_5 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True, default=['leader'])
-option_6 = StrOption(name='follower1', doc='follower1', multi=submulti, default_multi=['value'], properties=frozenset({'mandatory', 'normal'}))
+option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower1', doc='follower1', multi=submulti, default_multi=['value'])
-option_7 = StrOption(name='follower2', doc='follower2', multi=submulti, default_multi=['value1', 'value2'], properties=frozenset({'mandatory', 'normal'}))
+option_7 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower2', doc='follower2', multi=submulti, default_multi=['value1', 'value2'])
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership_defaultmulti_leader/tiramisu/base.py

@@ -12,11 +12,11 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non')
-option_5 = StrOption(name='leader', doc='leader', multi=True, default=['value'], properties=frozenset({'mandatory'}))
+option_5 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True, default=['value'])
-option_6 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'normal'}))
+option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True)
-option_7 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True)
-option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
+option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership_description/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_5 = Leadership(name='leader', doc='other description', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
+option_5 = Leadership(name='leader', doc='other description', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership_name/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
-option_5 = Leadership(name='other_name', doc='other_name', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
+option_5 = Leadership(name='other_name', doc='other_name', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership_normalize_family/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
-option_6 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({'mandatory'}))
+option_6 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True)
-option_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True)
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'basic'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'basic'}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='general_1', doc='general-1', children=[option_5], properties=frozenset({'basic'}))
+option_4 = OptionDescription(name='general_1', doc='general-1', properties=frozenset({'basic'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_leadership_submulti/tiramisu/base.py

@@ -12,12 +12,12 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'normal'}))
+option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
-option_8 = StrOption(name='follower2', doc='follower2', multi=submulti, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)))), properties=frozenset({'normal'}))
+option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=submulti, default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})), default_multi=[])
-option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
+option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
-option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
+option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2, option_4])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_mandatoryifin/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('mandatory'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_4 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('mandatory'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('mandatory'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}))
+option_5 = StrOption(properties=frozenset({'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('mandatory'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_mandatoryifnotin_noexist/tiramisu/base.py

@@ -12,9 +12,9 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'mandatory', 'normal'}))
+option_3 = ChoiceOption(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
-option_4 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_4 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
-option_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_5 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif2', doc='No change', multi=False, default='non')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])

tests/dictionaries/10load_multivalue/tiramisu/base.py

@@ -12,7 +12,7 @@ try:
 except:
     from tiramisu import *
 from rougail.tiramisu import ConvertDynOptionDescription
-option_3 = StrOption(name='mode_conteneur_actif', doc='No change', multi=True, default=['non', 'oui'], default_multi='oui', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
+option_3 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=True, default=['non', 'oui'], default_multi='oui')
-option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
+option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])