simplify tiramisureflector

FIXME

@@ -0,0 +1,5 @@
+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,10 +1,11 @@
 """Annotate dictionaries
 """
 from .group import GroupAnnotator
-from .service import ServiceAnnotator, ERASED_ATTRIBUTES
+from .service import ServiceAnnotator
 from .variable import VariableAnnotator, CONVERT_OPTION
 from .check import CheckAnnotator
-from .condition import Conditionnnotator
+from .value import ValueAnnotator
+from .condition import ConditionAnnotator
 from .fill import FillAnnotator
 from .family import FamilyAnnotator, modes
 from .property import PropertyAnnotator
@@ -20,12 +21,13 @@ class SpaceAnnotator:  # pylint: disable=R0903
         CheckAnnotator(objectspace,
                        eosfunc_file,
                        )
-        Conditionnnotator(objectspace)
+        ConditionAnnotator(objectspace)
         FillAnnotator(objectspace,
                       eosfunc_file,
                       )
         FamilyAnnotator(objectspace)
         PropertyAnnotator(objectspace)
+        ValueAnnotator(objectspace)
 
 
-__all__ = ('SpaceAnnotator', 'ERASED_ATTRIBUTES', 'CONVERT_OPTION', 'modes')
+__all__ = ('SpaceAnnotator', '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.choice = []
+        variable.values = []
         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.choice.append(choice)
+            variable.values.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)
-            else:
+                continue
-                if not hasattr(check.target, 'check'):
+            if not hasattr(check.target, 'validators'):
-                    check.target.check = []
+                check.target.validators = []
-                check.target.check.append(check)
+            check.target.validators.append(check)

src/rougail/annotator/condition.py

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

src/rougail/annotator/family.py

@@ -2,6 +2,8 @@
 """
 from ..i18n import _
 from ..error import DictConsistencyError
+from ..utils import normalize_family
+from .variable import RENAME_ATTIBUTES
 
 
 #mode order is important
@@ -34,13 +36,30 @@ class FamilyAnnotator:
                  objectspace,
                  ):
         self.objectspace = objectspace
-        if hasattr(self.objectspace.space, 'variables'):
+        if not 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 remove_empty_families(self):
+    def family_names(self) -> None:
+        """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():
@@ -169,9 +188,21 @@ class FamilyAnnotator:
             for family in families.family.values():
                 if 'dynamic' not in vars(family):
                     continue
-                family.dynamic = self.objectspace.paths.get_variable(family.dynamic)
+                family.suffixes = self.objectspace.paths.get_variable(family.dynamic)
-                if not family.dynamic.multi:
+                del family.dynamic
+                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,25 +26,27 @@ class PropertyAnnotator:
                          ) -> None:
         """convert properties
         """
-        properties = []
+        if not hasattr(variable, '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]):
-                        properties.append(subprop)
+                        variable.properties.append(subprop)
                 setattr(variable, prop, None)
         if hasattr(variable, 'mode') and variable.mode:
-            properties.append(variable.mode)
+            variable.properties.append(variable.mode)
             variable.mode = None
-        if 'force_store_value' in properties and \
+        if 'force_store_value' in variable.properties and \
-                'force_default_on_freeze' in properties:  # pragma: no cover
+                'force_default_on_freeze' in variable.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 properties:
+        if not variable.properties:
-            variable.properties = set(properties)
+            del variable.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',)
+                     'reflector_object', 'manage')
 
 
 KEY_TYPE = {'variable': 'symlink',
@@ -50,14 +50,12 @@ class ServiceAnnotator:
         self.objectspace.space.services.name = 'services'
         self.objectspace.space.services.doc = 'services'
         self.objectspace.space.services.path = 'services'
-        families = {}
+        for service_name, service in self.objectspace.space.services.service.items():
-        for service_name in self.objectspace.space.services.service.keys():
+            service.information = self.objectspace.information(service.xmlfiles)
-            service = self.objectspace.space.services.service[service_name]
+            service.information.manage = service.manage
-            new_service = self.objectspace.service(service.xmlfiles)
+            service.manage = None
-            new_service.path = f'services.{service_name}'
+            for elttype, values in dict(vars(service)).items():
-            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])
@@ -72,10 +70,8 @@ class ServiceAnnotator:
                                                           values,
                                                           path,
                                                           )
-                setattr(new_service, elttype, family)
+                setattr(service, elttype, family)
-            new_service.doc = new_service.name
+            service.doc = service.name
-            families[service_name] = new_service
-        self.objectspace.space.services.service = families
 
     def make_group_from_elts(self,
                              service_name,
@@ -187,10 +183,7 @@ class ServiceAnnotator:
             variable.multi = None
         else:
             variable.doc = key
-            val = self.objectspace.value(xmlfiles)
+            variable.default = value
-            val.type = type_
-            val.name = value
-            variable.value = [val]
             variable.namespace = 'services'
         self.objectspace.paths.add_variable('services',
                                             path,

src/rougail/annotator/value.py

@@ -0,0 +1,51 @@
+"""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,6 +1,5 @@
 """Annotate variable
 """
-from ..utils import normalize_family
 
 
 CONVERT_OPTION = {'number': dict(opttype="IntOption", func=int),
@@ -54,20 +53,13 @@ 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():
@@ -162,10 +154,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 not variable.test:
+            if variable.test:
-                del variable.test
-                return
                 values = variable.test.split('|')
                 new_values = []
                 for value in values:
@@ -174,4 +166,25 @@ class VariableAnnotator:  # pylint: disable=R0903
                     else:
                         value = CONVERT_OPTION.get(variable.type, {}).get('func', str)(value)
                     new_values.append(value)
-            variable.test = tuple(new_values)
+                variable.information.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')
+FORCE_ELEMENTS = ('choice', 'property_', 'leadership', 'information')
 # 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.space,
+        tiramisu_objects = TiramisuReflector(self.rougailobjspace,
                                              self.funcs_path,
                                              )
         return tiramisu_objects.get_text() + '\n'

src/rougail/tiramisureflector.py

@@ -2,13 +2,11 @@
 flattened XML specific
 """
 from .config import Config
-from .annotator import ERASED_ATTRIBUTES, CONVERT_OPTION
+from .annotator import CONVERT_OPTION
-#from .objspace import UnRedefinable, Redefinable, Atom
+from .objspace import RootRougailObject
 
 
 FUNC_TO_DICT = []
-FORCE_INFORMATIONS = ['help', 'test', 'manage']
-ATTRIBUTES_ORDER = ('name', 'doc', 'default', 'multi')
 
 
 class Root():  # pylint: disable=R0903
@@ -17,11 +15,19 @@ 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,
-                 space,
+                 objectspace,
                  funcs_path,
                  ):
         self.index = 0
@@ -40,63 +46,37 @@ class TiramisuReflector:
                      "    from tiramisu import *",
                      "from rougail.tiramisu import ConvertDynOptionDescription",
                      ]
-        self.make_tiramisu_objects(space)
+        self.objectspace = objectspace
+        self.make_tiramisu_objects()
 
-    def make_tiramisu_objects(self,
+    def make_tiramisu_objects(self) -> None:
-                              space,
-                              ):
         """make tiramisu objects
         """
         baseelt = BaseElt()
         self.set_name(baseelt)
         basefamily = Family(baseelt,
                             self.text,
+                            self.objectspace,
                             )
-        for elt in self.reorder_family(space):
+        for elt in self.reorder_family():
-            self.iter_family(basefamily,
+            self.populate_family(basefamily,
                                  elt,
                                  )
         # parse object
         baseelt.reflector_object.get()  # pylint: disable=E1101
 
-    @staticmethod
+    def reorder_family(self):
-    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(space, 'variables'):
+        if hasattr(self.objectspace.space, 'variables'):
-            if Config['variable_namespace'] in space.variables:
+            if Config['variable_namespace'] in self.objectspace.space.variables:
-                yield space.variables[Config['variable_namespace']]
+                yield self.objectspace.space.variables[Config['variable_namespace']]
-            for elt, value in space.variables.items():
+            for elt, value in self.objectspace.space.variables.items():
                 if elt != Config['variable_namespace']:
                     yield value
-        if hasattr(space, 'services'):
+        if hasattr(self.objectspace.space, 'services'):
-            yield space.services
+            yield self.objectspace.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,
@@ -107,46 +87,32 @@ class TiramisuReflector:
         self.set_name(elt)
         family = Family(elt,
                         self.text,
+                        self.objectspace,
                         )
         parent_family.add(family)
-        for children in self.get_children(elt):
+        for children in vars(elt).values():
-            for child in children:
+            if isinstance(children, self.objectspace.family):
-                self.iter_family(family,
+                self.populate_family(family,
-                                 child,
+                                     children,
                                      )
-
+                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):
-                yield children
+                for child in children:
-
+                    if isinstance(child, self.objectspace.property_) or \
-    def populate_variable(self,
+                            not isinstance(child, RootRougailObject):
-                          family,
+                        continue
-                          elt,
+                    if isinstance(child, self.objectspace.variable):
-                          ):
+                        self.set_name(child)
-        """Populate variable
+                        family.add(Variable(child,
-        """
-        if family.is_leadership:
-            is_leader = elt.name == family.elt.variable[0].name
-            is_follower = not is_leader
-        else:
-            is_leader = False
-            is_follower = False
-        self.set_name(elt)
-        family.add(Variable(elt,
                                             self.text,
-                            is_follower,
+                                            self.objectspace,
-                            is_leader,
                                             ))
+                    else:
+                        self.populate_family(family,
+                                             child,
+                                             )
 
     def set_name(self,
                  elt,
@@ -162,100 +128,85 @@ 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 populate_properties(self, child):
+    def get(self):
+        """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)"
-        prop = 'Calculation(calc_value, Params(' + action + ', kwargs={' + kwargs + '}))'
+        return f"Calculation(calc_value, Params(ParamValue('{child.name}'), 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
         """
-        for key, value in self.informations.items():
+        if not hasattr(self.elt, 'information'):
+            return
+        for key, value in vars(self.elt.information).items():
+            if key == 'xmlfiles':
+                continue
             if isinstance(value, str):
-                value = '"' + value.replace('"', '\"') + '"'
+                value = self.convert_str(value)
-            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):
@@ -264,100 +215,41 @@ class Variable(Common):
     def __init__(self,
                  elt,
                  text,
-                 is_follower,
+                 objectspace,
-                 is_leader,
                  ):
-        super().__init__(elt, text)
+        super().__init__(elt, text, objectspace)
-        self.is_leader = is_leader
+        self.object_type = CONVERT_OPTION[elt.type]['opttype']
-        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 get(self):
+    def _populate_attrib(self,
-        """Get tiramisu's object
+                         keys: dict,
-        """
+                         ):
-        if self.option_name is None:
+        if hasattr(self.elt, 'opt'):
-            self.populate_attrib()
+            keys['opt'] = self.elt.opt.reflector_object.get()
-            if self.object_type == 'SymLinkOption':
+        if hasattr(self.elt, 'values'):
-                self.attrib['opt'] = self.attrib['opt'].reflector_object.get()
+            values = self.elt.values
+            if values[0].type == 'calculation':
+                value = values[0].name.reflector_object.get()
+                keys['values'] = f"Calculation(func.calc_value, Params((ParamOption({value}))))"
             else:
-                self.parse_children()
+                keys['values'] = str(tuple([val.name for val in values]))
-            attrib = self.get_attrib()
+        if hasattr(self.elt, 'multi') and self.elt.multi:
-            self.option_name = self.elt.reflector_name
+            keys['multi'] = self.elt.multi
-            self.text.append(f'{self.option_name} = {self.object_type}({attrib})')
+        for key in ['default', 'default_multi']:
-            self.populate_informations()
+            if hasattr(self.elt, key) and getattr(self.elt, key) is not None:
-        return self.option_name
-
-    def populate_attrib(self):
-        """Populate attributes
-        """
-        for key in self.get_attributes(self.elt):
                 value = getattr(self.elt, key)
-            if key in FORCE_INFORMATIONS:
+                if isinstance(value, str):
-                self.informations[key] = value
+                    value = self.convert_str(value)
-            else:
+                elif isinstance(value, self.objectspace.value):
-                self.attrib[key] = value
+                    value = self.calculation_value(value, [])
-
+                keys[key] = value
-    def parse_children(self):
+        if hasattr(self.elt, 'validators'):
-        """Parse children
+            keys['validators'] = '[' + ', '.join([self.calculation_value(val,
-        """
+                                    ['ParamSelfOption()']) for val in self.elt.validators]) + ']'
-        if 'default' not in self.attrib or self.attrib['multi']:
+        for key in ['min_number', 'max_number']:
-            self.attrib['default'] = []
+            if hasattr(self.elt, key):
-        if self.attrib['multi'] == 'submulti' and self.is_follower:
+                keys[key] = getattr(self.elt, key)
-            self.attrib['default_multi'] = []
+        for key, value in CONVERT_OPTION[self.elt.type].get('initkwargs', {}).items():
-        choices = []
+            keys[key] = value
-        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,
@@ -375,8 +267,10 @@ 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) + ')'
-                "), kwargs=" + "{" + ', '.join(kwargs) + "})"
+        if kwargs:
+            ret += ', kwargs={' + ', '.join(kwargs) + '}'
+        ret += ')'
         if hasattr(child, 'warnings_only'):
             ret += f', warnings_only={child.warnings_only}'
         return ret + ')'
@@ -388,55 +282,32 @@ class Variable(Common):
         """Populate variable parameters
         """
         if param.type == 'string':
-            return f'ParamValue("{param.text}")'
+            value = 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':
-            value = {'option': param.text,
+            return self.build_param(param, function)
-                     '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) -> str:
+    def build_param(param,
+                    function: str,
+                    ) -> str:
         """build variable parameters
         """
-        option_name = param['option'].reflector_object.get()
+        option_name = param.text.reflector_object.get()
-        ends = f"notraisepropertyerror={param['notraisepropertyerror']}, todict={param['todict']})"
+        todict = function in FUNC_TO_DICT
-        if 'suffix' in param:
+        ends = f"notraisepropertyerror={param.notraisepropertyerror}, todict={todict})"
-            family_name = param['family'].reflector_name
+        if hasattr(param, 'suffix'):
-            return f"ParamDynOption({option_name}, '{param['suffix']}', {family_name}, {ends}"
+            family_name = param.family.reflector_name
+            return f"ParamDynOption({option_name}, '{param.suffix}', {family_name}, {ends}"
         return f"ParamOption({option_name}, {ends}"
 
 
@@ -446,9 +317,15 @@ class Family(Common):
     def __init__(self,
                  elt,
                  text,
+                 objectspace,
                  ):
-        super().__init__(elt, text)
+        super().__init__(elt, text, objectspace)
-        self.is_leadership = self.elt.__class__.__name__ == 'Leadership'
+        if hasattr(self.elt, 'suffixes'):
+            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):
@@ -456,48 +333,10 @@ class Family(Common):
         """
         self.children.append(child)
 
-    def get(self):
+    def _populate_attrib(self,
-        """Get tiramisu's object
+                         keys: list,
-        """
+                         ) -> None:
-        if not self.option_name:
+        if hasattr(self.elt, 'suffixes'):
-            self.populate_attrib()
+            dyn = self.elt.suffixes.reflector_object.get()
-            self.parse_children()
+            keys['suffixes'] = f"Calculation(func.calc_value, Params((ParamOption({dyn}))))"
-            self.option_name = self.elt.reflector_name
+        keys['children'] = '[' + ', '.join([child.get() for child in self.children]) + ']'
-            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', properties=frozenset({'hidden'}), children=[option_2])
+option_1 = OptionDescription(name='services', doc='services', children=[option_2], properties=frozenset({'hidden'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_2 = OptionDescription(name='general', doc='général', properties=frozenset({'basic'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'basic', 'force_store_value', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'basic', 'force_store_value', 'mandatory'}))
-option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'basic'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'basic'}))
 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(properties=frozenset({'expert', 'force_store_value', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'force_store_value', 'mandatory'}))
-option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'expert'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'expert'}))
 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(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = 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({'mandatory', 'normal'}), name='without_type', doc='without_type', multi=False, default='non')
+option_4 = StrOption(name='without_type', doc='without_type', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = 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_actif1', 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_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', '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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(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_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_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='Description', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='Description', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
-option_8 = StrOption(name='group', doc='group', multi=False, default='root')
+option_8 = StrOption(name='group', doc='group', default='root')
-option_9 = StrOption(name='mode', doc='mode', multi=False, default='0644')
+option_9 = StrOption(name='mode', doc='mode', default='0644')
-option_10 = StrOption(name='name', doc='name', multi=False, default='/etc/file')
+option_10 = StrOption(name='name', doc='name', default='/etc/file')
-option_11 = StrOption(name='owner', doc='owner', multi=False, default='root')
+option_11 = StrOption(name='owner', doc='owner', default='root')
-option_12 = StrOption(name='source', doc='source', multi=False, default='file')
+option_12 = StrOption(name='source', doc='source', default='file')
-option_13 = BoolOption(name='templating', doc='templating', multi=False, default=True)
+option_13 = BoolOption(name='templating', doc='templating', default=True)
-option_14 = BoolOption(name='activate', doc='activate', multi=False, default=True)
+option_14 = BoolOption(name='activate', doc='activate', 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', properties=frozenset({'hidden'}), children=[option_5])
+option_4 = OptionDescription(name='services', doc='services', children=[option_5], properties=frozenset({'hidden'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='Description', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='Description', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
-option_8 = StrOption(name='group', doc='group', multi=False, default='root')
+option_8 = StrOption(name='group', doc='group', default='root')
-option_9 = StrOption(name='mode', doc='mode', multi=False, default='0644')
+option_9 = StrOption(name='mode', doc='mode', default='0644')
-option_10 = StrOption(name='name', doc='name', multi=False, default='/etc/file')
+option_10 = StrOption(name='name', doc='name', default='/etc/file')
-option_11 = StrOption(name='owner', doc='owner', multi=False, default='root')
+option_11 = StrOption(name='owner', doc='owner', default='root')
-option_12 = StrOption(name='source', doc='source', multi=False, default='file')
+option_12 = StrOption(name='source', doc='source', default='file')
-option_13 = BoolOption(name='templating', doc='templating', multi=False, default=True)
+option_13 = BoolOption(name='templating', doc='templating', default=True)
-option_14 = BoolOption(name='activate', doc='activate', multi=False, default=True)
+option_14 = BoolOption(name='activate', doc='activate', 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', properties=frozenset({'hidden'}), children=[option_5])
+option_4 = OptionDescription(name='services', doc='services', children=[option_5], properties=frozenset({'hidden'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='Description', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='Description', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
-option_8 = StrOption(name='group', doc='group', multi=False, default='root')
+option_8 = StrOption(name='group', doc='group', default='root')
-option_9 = StrOption(name='mode', doc='mode', multi=False, default='0644')
+option_9 = StrOption(name='mode', doc='mode', default='0644')
-option_10 = StrOption(name='name', doc='name', multi=False, default='/etc/systemd-makefs@dev-disk-by\\x2dpartlabel')
+option_10 = StrOption(name='name', doc='name', default='/etc/systemd-makefs@dev-disk-by\\x2dpartlabel')
-option_11 = StrOption(name='owner', doc='owner', multi=False, default='root')
+option_11 = StrOption(name='owner', doc='owner', default='root')
-option_12 = StrOption(name='source', doc='source', multi=False, default='systemd-makefs@dev-disk-by\\x2dpartlabel')
+option_12 = StrOption(name='source', doc='source', default='systemd-makefs@dev-disk-by\\x2dpartlabel')
-option_13 = BoolOption(name='templating', doc='templating', multi=False, default=True)
+option_13 = BoolOption(name='templating', doc='templating', default=True)
-option_14 = BoolOption(name='activate', doc='activate', multi=False, default=True)
+option_14 = BoolOption(name='activate', doc='activate', 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', properties=frozenset({'hidden'}), children=[option_5])
+option_4 = OptionDescription(name='services', doc='services', children=[option_5], properties=frozenset({'hidden'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='float', doc='Description', multi=False, default=0.527)
+option_3 = FloatOption(name='float', doc='Description', default=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_4 = FloatOption(name='float_multi', doc='Description', multi=True, default=[0.527], default_multi=0.527, properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='general', doc='description', multi=False, default='non')
+option_3 = StrOption(name='general', doc='description', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='Other description', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='Other description', children=[option_3], properties=frozenset({'normal'}))
 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_5 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
+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='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', '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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', '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_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_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(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_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_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(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_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_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', properties=frozenset({'mandatory', '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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='module_instancie', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='module_instancie', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_3.impl_set_information("test", ('test',))
+option_3.impl_set_information('test', ('test',))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_3.impl_set_information("test", ('test1', 'test2'))
+option_3.impl_set_information('test', ('test1', 'test2'))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
-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', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_3.impl_set_information("test", ('test1',))
+option_3.impl_set_information('test', ('test1',))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='mode_conteneur_actif', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='mode_conteneur_actif', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = 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({'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_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_2 = OptionDescription(name='general', doc='général', properties=frozenset({'basic'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'basic'}))
 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(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = 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({'basic', 'force_store_value', 'frozen', 'hidden'}), name='autosavevar', doc='autosave variable', multi=False, default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
+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_2 = OptionDescription(name='general', doc='général', properties=frozenset({'basic'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', 'normal'}))
-option_4 = IntOption(properties=frozenset({'normal'}), name='int', doc='No change', multi=False, max_number=100, min_number=0)
+option_4 = IntOption(name='int', doc='No change', min_number=0, max_number=100, properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', '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_4 = IntOption(name='int', doc='No change', validators=[Calculation(func.valid_lower, Params((ParamSelfOption())), warnings_only=False)], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', 'normal'}))
-option_4 = IntOption(properties=frozenset({'mandatory', 'normal'}), name='int2', doc='No change', multi=False, default=100)
+option_4 = IntOption(name='int2', doc='No change', default=100, properties=frozenset({'mandatory', '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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='b')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='b', properties=frozenset({'mandatory', 'normal'}))
-option_5 = IntOption(properties=frozenset({'normal'}), name='int2', doc='No change', multi=False)
+option_5 = IntOption(name='int2', doc='No change', 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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', doc='No change', default='non', 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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
-option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', 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_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', 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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5, option_6])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5, option_6], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
-option_4 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif1', doc='No change', multi=False, default='non')
+option_4 = StrOption(name='mode_conteneur_actif1', 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_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', 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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5, option_6])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5, option_6], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
-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_4 = IPOption(name='adresse_ip_eth0', doc='Adresse IP de la carte', private_only=True, warnings_only=True, 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_5 = NetmaskOption(name='adresse_netmask_eth0', doc='Masque de sous réseau de la carte', 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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5, option_6])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5, option_6], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
-option_4 = IPOption(cidr=True, properties=frozenset({'basic', 'mandatory'}), name='adresse_ip_eth0', doc='Adresse IP de la carte', multi=False)
+option_4 = IPOption(name='adresse_ip_eth0', doc='Adresse IP de la carte', cidr=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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'mandatory', 'normal'}))
-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_4 = IPOption(name='adresse_ip_eth0', doc='Adresse IP de la carte', private_only=True, 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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'basic'}))
 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(properties=frozenset({'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default=Calculation(func.calc_val, Params((ParamInformation("test_information", None)), kwargs={})))
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default=Calculation(func.calc_val, Params((ParamInformation("test_information", None)))), properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), 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_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_9 = StrOption(properties=frozenset({'normal'}), name='follower3', doc='follower3', multi=True)
+option_9 = StrOption(name='follower3', doc='follower3', multi=True, properties=frozenset({'normal'}))
-option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8, option_9])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8, option_9], properties=frozenset({'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
-option_6 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen'}), name='leader', doc='leader', multi=True)
+option_6 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({'force_default_on_freeze', 'frozen'}))
-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_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_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_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_9 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}), name='follower3', doc='follower3', multi=True)
+option_9 = StrOption(name='follower3', doc='follower3', multi=True, properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}))
-option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'hidden', 'normal'}), children=[option_6, option_7, option_8, option_9])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8, option_9], properties=frozenset({'hidden', 'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), 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_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_9 = StrOption(properties=frozenset({'normal'}), name='follower3', doc='follower3', multi=True)
+option_9 = StrOption(name='follower3', doc='follower3', multi=True, properties=frozenset({'normal'}))
-option_5 = Leadership(name='leadership', doc='leadership', properties=frozenset({'normal'}), children=[option_6, option_7, option_8, option_9])
+option_5 = Leadership(name='leadership', doc='leadership', children=[option_6, option_7, option_8, option_9], properties=frozenset({'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-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_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_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_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_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_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_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7, option_8])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7, option_8], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-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_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_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_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_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
-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(properties=frozenset({'expert'}), name='follower1', doc='follower1', multi=True)
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'expert'}))
-option_8 = StrOption(properties=frozenset({'expert'}), name='follower2', doc='follower2', multi=True)
+option_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'expert'}))
-option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'expert'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'expert'}))
-option_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'expert'}), children=[option_5])
+option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'expert'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_6 = 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({'expert'}), name='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+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_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_6 = 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='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+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_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
-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_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_7 = StrOption(properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}), name='follower1', doc='follower1', multi=True)
+option_7 = StrOption(name='follower1', doc='follower1', 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_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'force_default_on_freeze', 'frozen', 'normal'}))
-option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'hidden', 'normal'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'hidden', 'normal'}))
-option_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
-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_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_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_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_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_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_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_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_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'expert', 'mandatory'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'expert', 'mandatory'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'expert'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'expert'}))
-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_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_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_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_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_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_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_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_4 = OptionDescription(name='leadermode', doc='leadermode', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='leadermode', doc='leadermode', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_5 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True)
+option_5 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({'mandatory'}))
-option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_6 = 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='follower2', doc='follower2', multi=True, default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+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_4 = Leadership(name='leader', doc='leader', properties=frozenset({'basic'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'basic'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'basic'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_6 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), properties=frozenset({'mandatory', '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_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_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='oui')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='oui', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
 option_5 = NetmaskOption(name='nut_monitor_netmask', doc='Masque de l\'IP du réseau de l\'esclave', multi=True)
-option_6 = NetworkOption(properties=frozenset({'mandatory', 'normal'}), name='nut_monitor_host', doc='Adresse 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_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_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_2 = OptionDescription(name='general', doc='général', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='général', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), 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_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_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
 option_10 = StrOption(name='leader1', doc='leader', multi=True)
-option_11 = StrOption(properties=frozenset({'normal'}), name='follower11', doc='follower1', multi=True)
+option_11 = StrOption(name='follower11', doc='follower1', multi=True, properties=frozenset({'normal'}))
-option_12 = StrOption(properties=frozenset({'normal'}), name='follower21', doc='follower2', multi=True)
+option_12 = StrOption(name='follower21', doc='follower2', multi=True, properties=frozenset({'normal'}))
-option_9 = Leadership(name='leader1', doc='leader', properties=frozenset({'normal'}), children=[option_10, option_11, option_12])
+option_9 = Leadership(name='leader1', doc='leader', children=[option_10, option_11, option_12], properties=frozenset({'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5, option_9])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5, option_9], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4, option_5], properties=frozenset({'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_7 = StrOption(name='mode_conteneur_actif3', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
-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_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_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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_4 = StrOption(properties=frozenset({'disabled', 'mandatory', 'normal'}), name='mode_conteneur_actif', 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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'normal'}), name='mode_conteneur_actif', doc='No change', multi=False)
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', properties=frozenset({'normal'}))
-option_4 = StrOption(properties=frozenset({'normal'}), name='mode_conteneur_actif2', doc='No change', multi=False)
+option_4 = StrOption(name='mode_conteneur_actif2', doc='No change', properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
+option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
+option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'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_4 = StrOption(name='mode_conteneur_actif', 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_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
+option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'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_4 = StrOption(name='mode_conteneur_actif', 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_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='Général', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='Général', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
-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_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_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_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_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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), 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_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_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non', properties=frozenset({'mandatory', 'normal'}))
 option_5 = StrOption(name='leader', doc='leader', multi=True)
-option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower1', doc='follower1', multi=True, default_multi='value')
+option_6 = StrOption(name='follower1', doc='follower1', multi=True, default_multi='value', properties=frozenset({'mandatory', 'normal'}))
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True)
+option_7 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal'}))
-option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non', properties=frozenset({'mandatory', 'normal'}))
-option_5 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True, default=['leader'])
+option_5 = StrOption(name='leader', doc='leader', multi=True, default=['leader'], properties=frozenset({'mandatory'}))
-option_6 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower1', doc='follower1', multi=submulti, default_multi=['value'])
+option_6 = StrOption(name='follower1', doc='follower1', multi=submulti, default_multi=['value'], properties=frozenset({'mandatory', 'normal'}))
-option_7 = StrOption(properties=frozenset({'mandatory', 'normal'}), name='follower2', doc='follower2', multi=submulti, default_multi=['value1', 'value2'])
+option_7 = StrOption(name='follower2', doc='follower2', multi=submulti, default_multi=['value1', 'value2'], properties=frozenset({'mandatory', 'normal'}))
-option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='leader', multi=True, default=['non'], default_multi='non', properties=frozenset({'mandatory', 'normal'}))
-option_5 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True, default=['value'])
+option_5 = StrOption(name='leader', doc='leader', multi=True, default=['value'], properties=frozenset({'mandatory'}))
-option_6 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True)
+option_6 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'normal'}))
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True)
+option_7 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal'}))
-option_4 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_5, option_6, option_7])
+option_4 = Leadership(name='leader', doc='leader', children=[option_5, option_6, option_7], properties=frozenset({'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), 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_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_5 = Leadership(name='leader', doc='other description', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='leader', doc='other description', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), 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_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_5 = Leadership(name='other_name', doc='other_name', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='other_name', doc='other_name', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
-option_6 = StrOption(properties=frozenset({'mandatory'}), name='leader', doc='leader', multi=True)
+option_6 = StrOption(name='leader', doc='leader', multi=True, properties=frozenset({'mandatory'}))
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True)
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, properties=frozenset({'normal'}))
-option_8 = StrOption(properties=frozenset({'normal'}), name='follower2', doc='follower2', multi=True)
+option_8 = StrOption(name='follower2', doc='follower2', multi=True, properties=frozenset({'normal'}))
-option_5 = Leadership(name='leader', doc='leader', properties=frozenset({'basic'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'basic'}))
-option_4 = OptionDescription(name='general_1', doc='general-1', properties=frozenset({'basic'}), children=[option_5])
+option_4 = OptionDescription(name='general_1', doc='general-1', children=[option_5], properties=frozenset({'basic'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='mode_conteneur_actif', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='mode_conteneur_actif', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_6 = StrOption(name='leader', doc='leader', multi=True)
-option_7 = StrOption(properties=frozenset({'normal'}), name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(name='follower1', doc='follower1', multi=True, default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue('valfill')})), 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_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_5 = Leadership(name='leader', doc='leader', properties=frozenset({'normal'}), children=[option_6, option_7, option_8])
+option_5 = Leadership(name='leader', doc='leader', children=[option_6, option_7, option_8], properties=frozenset({'normal'}))
-option_4 = OptionDescription(name='general1', doc='general1', properties=frozenset({'normal'}), children=[option_5])
+option_4 = OptionDescription(name='general1', doc='general1', children=[option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='non')
+option_3 = StrOption(name='condition', doc='No change', default='non', properties=frozenset({'mandatory', 'normal'}))
-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_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_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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(properties=frozenset({'mandatory', 'normal'}), name='condition', doc='No change', multi=False, default='tous', values=('tous', 'authentifié', 'aucun'))
+option_3 = ChoiceOption(name='condition', doc='No change', values=('tous', 'authentifié', 'aucun'), default='tous', properties=frozenset({'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_4 = StrOption(name='mode_conteneur_actif', 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_5 = StrOption(name='mode_conteneur_actif2', doc='No change', default='non', properties=frozenset({'force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal'}))
-option_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3, option_4, option_5])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3, option_4, option_5], properties=frozenset({'normal'}))
 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(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_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_2 = OptionDescription(name='general', doc='general', properties=frozenset({'normal'}), children=[option_3])
+option_2 = OptionDescription(name='general', doc='general', children=[option_3], properties=frozenset({'normal'}))
 option_1 = OptionDescription(name='rougail', doc='rougail', children=[option_2])
 option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])