feat: can sort dictionaries in different directories

src/rougail/__init__.py

@@ -27,10 +27,11 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 """
-from tiramisu import Config
+from tiramisu import Config, undefined
-from tiramisu.error import PropertiesOptionError
+from tiramisu.error import PropertiesOptionError, LeadershipError, ConfigError
 from warnings import warn
 from typing import List
+from re import compile, findall
 
 from .convert import RougailConvert
 from .config import RougailConfig
@@ -39,15 +40,20 @@ from .object_model import CONVERT_OPTION
 from .utils import normalize_family
 
 
-def tiramisu_display_name(kls, subconfig) -> str:
+def tiramisu_display_name(kls,
+                          subconfig,
+                          with_quote: bool=False,
+                          ) -> str:
     """Replace the Tiramisu display_name function to display path + description"""
     doc = kls._get_information(subconfig, "doc", None)
     comment = f" ({doc})" if doc and doc != kls.impl_getname() else ""
-    if "{{ suffix }}" in comment:
+    if "{{ identifier }}" in comment:
-        comment = comment.replace('{{ suffix }}', str(subconfig.suffixes[-1]))
+        comment = comment.replace('{{ identifier }}', str(subconfig.identifiers[-1]))
     path = kls.impl_getpath()
-    if "{{ suffix }}" in path:
+    if "{{ identifier }}" in path and subconfig.identifiers:
-        path = path.replace('{{ suffix }}', normalize_family(str(subconfig.suffixes[-1])))
+        path = path.replace('{{ identifier }}', normalize_family(str(subconfig.identifiers[-1])))
+    if with_quote:
+        return f'"{path}"{comment}'
     return f"{path}{comment}"
 
 
@@ -96,37 +102,194 @@ class Rougail:
         errors = []
         warnings = []
         for datas in user_datas:
+            options = datas.get('options', {})
             for name, data in datas.get('values', {}).items():
-                values.setdefault(name, {}).update(data)
+                values[name] = {'values': data,
+                                'options': options.copy(),
+                                }
             errors.extend(datas.get('errors', []))
             warnings.extend(datas.get('warnings', []))
+        self._auto_configure_dynamics(values)
         while values:
             value_is_set = False
-            for option in self.config:
+            for option in self._get_variable(self.config):
-                if option.path() in values and option.index() in values[option.path()]:
+                path = option.path()
+                if path not in values:
+                    path = path.upper()
+                    options = values.get(path, {}).get('options', {})
+                    if path not in values or options.get('upper') is not True:
+                        continue
+                else:
+                    options = values[path].get('options', {})
+                value = values[path]["values"]
+                if option.ismulti():
+                    if options.get('multi_separator') and not isinstance(value, list):
+                        value = value.split(options['multi_separator'])
+                        values[path]["values"] = value
+                    if options.get('needs_convert'):
+                        value = [convert_value(option, val) for val in value]
+                        values[path]["values"] = value
+                        values[path]["options"]["needs_convert"] = False
+                elif options.get('needs_convert'):
+                    value = convert_value(option, value)
+                index = option.index()
+                if index is not None:
+                    if not isinstance(value, list) or index >= len(value):
+                        continue
+                    value = value[index]
                 try:
-                        option.value.set(values[option.path()])
+                    option.value.set(value)
                     value_is_set = True
-                        values.pop(option.path())
+                    if index is not None:
-                    except:
+                        values[path]['values'][index] = undefined
-                        pass
+                        if set(values[path]['values']) == {undefined}:
+                            values.pop(path)
+                    else:
+                        values.pop(path)
+                except Exception as err:
+                    if path != option.path():
+                        values[option.path()] = values.pop(path)
             if not value_is_set:
                 break
         for path, data in values.items():
-            for index, value in data.items():
             try:
-                    print('attention', path, value)
+                option = self.config.option(path)
-                    self.config.option(path).value.set(value)
+                value = data['values']
-                    print('pfff')
+                if option.isfollower():
+                    for index, val in enumerate(value):
+                        if val is undefined:
+                            continue
+                        self.config.option(path, index).value.set(val)
+                else:
+                    option.value.set(value)
             except AttributeError as err:
                 errors.append(str(err))
-                except ValueError as err:
+            except (ValueError, LeadershipError) as err:
-                    errors.append(str(err).replace('"', "'"))
+                #errors.append(str(err).replace('"', "'"))
+                errors.append(str(err))
             except PropertiesOptionError as err:
-    #                warnings.append(f'"{err}" but is defined in "{self.filename}"')
+#                warnings.append(f'"{err}" but is defined in "{self.filename}"')
                 warnings.append(str(err))
         return {'errors': errors,
                 'warnings': warnings,
                 }
 
+    def _get_variable(self, config):
+        for subconfig in config:
+            if subconfig.isoptiondescription():
+                yield from self._get_variable(subconfig)
+            else:
+                yield subconfig
+
+    def _auto_configure_dynamics(self,
+                                 values,
+                                 ):
+        cache = {}
+        added = []
+        for path, data in list(values.items()):
+            value = data['values']
+#            for value in data['values'].items():
+            try:
+                option = self.config.option(path)
+                option.name()
+            except (ConfigError, PropertiesOptionError):
+                pass
+            except AttributeError:
+                config = self.config
+                current_path = ''
+                identifiers = []
+                for name in path.split('.')[:-1]:
+                    if current_path:
+                        current_path += '.'
+                    current_path += name
+                    if current_path in cache:
+                        config, identifier = cache[current_path]
+                        identifiers.append(identifier)
+                    else:
+                        tconfig = config.option(name)
+                        try:
+                            tconfig.group_type()
+                            config = tconfig
+                        except AttributeError:
+                            for tconfig in config.list(uncalculated=True):
+                                if tconfig.isdynamic(only_self=True):
+                                    identifier = self._get_identifier(tconfig.name(), name)
+                                    if identifier is None:
+                                        continue
+                                    dynamic_variable = tconfig.information.get('dynamic_variable',
+                                                                               None,
+                                                                               )
+                                    if not dynamic_variable:
+                                        continue
+                                    option_type = self.config.option(dynamic_variable).information.get('type')
+                                    if identifiers:
+                                        for s in identifiers:
+                                            dynamic_variable = dynamic_variable.replace('{{ identifier }}', str(s), 1)
+                                    if dynamic_variable not in values:
+                                        values[dynamic_variable] = {'values': []}
+                                        added.append(dynamic_variable)
+                                    elif dynamic_variable not in added:
+                                        continue
+                                    config = tconfig
+#                                        option_type = option.information.get('type')
+                                    typ = CONVERT_OPTION.get(option_type, {}).get("func")
+                                    if typ:
+                                        identifier = typ(identifier)
+                                    if identifier not in values[dynamic_variable]['values']:
+                                        values[dynamic_variable]['values'].append(identifier)
+                                    identifiers.append(identifier)
+                                    cache[current_path] = config, identifier
+                                    break
+            else:
+                if option.isdynamic():
+                    parent_option = self.config.option(path.rsplit('.', 1)[0])
+                    identifiers = self._get_identifier(parent_option.name(uncalculated=True),
+                                                parent_option.name(),
+                                                )
+                    dynamic_variable = None
+                    while True:
+                        dynamic_variable = parent_option.information.get('dynamic_variable',
+                                                                         None,
+                                                                         )
+                        if dynamic_variable:
+                            break
+                        parent_option = self.config.option(parent_option.path().rsplit('.', 1)[0])
+                        if '.' not in parent_option.path():
+                            parent_option = None
+                            break
+                    if not parent_option:
+                        continue
+                    identifiers = parent_option.identifiers()
+                    for identifier in identifiers:
+                        dynamic_variable = dynamic_variable.replace('{{ identifier }}', str(identifier), 1)
+                    if dynamic_variable not in values:
+                        values[dynamic_variable] = {'values': []}
+                        added.append(dynamic_variable)
+                    elif dynamic_variable not in added:
+                        continue
+                    option_type = option.information.get('type')
+                    typ = CONVERT_OPTION.get(option_type, {}).get("func")
+                    if typ:
+                        identifier = typ(identifier)
+                    if identifier not in values[dynamic_variable]['values']:
+                        values[dynamic_variable]['values'].append(identifier)
+                    cache[option.path()] = option, identifier
+
+    def _get_identifier(self, true_name, name) -> str:
+        regexp = true_name.replace("{{ identifier }}", "(.*)")
+        finded = findall(regexp, name)
+        if len(finded) != 1 or not finded[0]:
+            return
+        return finded[0]
+
+def convert_value(option, value):
+    if value == '':
+        return None
+    option_type = option.information.get('type')
+    func = CONVERT_OPTION.get(option_type, {}).get("func")
+    if func:
+        return func(value)
+    return value
+
+
 __all__ = ("Rougail", "RougailConfig", "RougailUpgrade")

src/rougail/annotator/family.py

@@ -66,7 +66,7 @@ class Annotator(Walk):
             return
         self.check_leadership()
         self.remove_empty_families()
-        self.family_names()
+        self.family_description()
         if self.objectspace.modes_level:
             self.modes = {
                 name: Mode(idx)
@@ -75,6 +75,11 @@ class Annotator(Walk):
             self.default_variable_mode = self.objectspace.default_variable_mode
             self.default_family_mode = self.objectspace.default_family_mode
             self.change_modes()
+        else:
+            for family in self.get_families():
+                self.valid_mode(family)
+            for variable in self.get_variables():
+                self.valid_mode(variable)
         self.convert_help()
 
     def check_leadership(self) -> None:
@@ -113,11 +118,15 @@ class Annotator(Walk):
                 return True
         return False
 
-    def family_names(self) -> None:
+    def family_description(self) -> None:
-        """Set doc, path, ... to family"""
         for family in self.get_families():
             if not family.description:
                 family.description = family.name
+            if family.type == 'dynamic' and isinstance(family.dynamic, VariableCalculation):
+                path = self.objectspace.paths.get_full_path(family.dynamic.variable,
+                                                            family.path,
+                                                            )
+                self.objectspace.informations.add(family.path, "dynamic_variable", path)
 
     def change_modes(self):
         """change the mode of variables"""
@@ -159,10 +168,16 @@ class Annotator(Walk):
     ) -> None:
         modes_level = self.objectspace.modes_level
         if self._has_mode(obj) and obj.mode not in modes_level:
+            if modes_level:
                 msg = _(
                     f'mode "{obj.mode}" for "{obj.name}" is not a valid mode, '
                     f"valid modes are {modes_level}"
                 )
+            else:
+                msg = _(
+                    f'mode "{obj.mode}" for "{obj.name}" is not a valid mode, '
+                    f"no modes are available"
+                )
             raise DictConsistencyError(msg, 71, obj.xmlfiles)
 
     def _set_default_mode(

src/rougail/annotator/variable.py

@@ -75,11 +75,11 @@ class Annotator(Walk):  # pylint: disable=R0903
             self.forbidden_name = []
         # default type inference from a default value with :term:`basic types`
         self.basic_types = {str: "string", int: "number", bool: "boolean", float: "float"}
+        self.verify_choices()
         self.convert_variable()
         self.convert_test()
         self.convert_examples()
         self.convert_help()
-        self.verify_choices()
 
     def convert_variable(self):
         """convert variable"""
@@ -135,7 +135,7 @@ class Annotator(Walk):  # pylint: disable=R0903
             return
         # copy type and params
         calculated_variable_path = variable.default.variable
-        calculated_variable, suffix = self.objectspace.paths.get_with_dynamic(
+        calculated_variable, identifier = self.objectspace.paths.get_with_dynamic(
             calculated_variable_path, variable.default.path_prefix, variable.path, variable.version, variable.namespace, variable.xmlfiles
         )
         if calculated_variable is None:
@@ -171,15 +171,14 @@ class Annotator(Walk):  # pylint: disable=R0903
             family = self.objectspace.paths[variable.path.rsplit(".", 1)[0]]
             if variable.hidden:
                 family.hidden = variable.hidden
-            elif family.hidden:
+#            elif family.hidden:
-                variable.hidden = family.hidden
+#                variable.hidden = family.hidden
             variable.hidden = None
-        if variable.choices is not None and variable.type != 'choice':
-            msg = _(f'the variable "{variable.path}" has choices attribut but has not the "choice" type')
-            raise DictConsistencyError(msg, 11, variable.xmlfiles)
         if variable.regexp is not None and variable.type != 'regexp':
             msg = _(f'the variable "{variable.path}" has regexp attribut but has not the "regexp" type')
             raise DictConsistencyError(msg, 37, variable.xmlfiles)
+        if variable.mandatory is None:
+            variable.mandatory = True
 
     def convert_test(self):
         """Convert variable tests value"""
@@ -213,8 +212,18 @@ class Annotator(Walk):  # pylint: disable=R0903
 
     def verify_choices(self):
         for variable in self.get_variables():
-            if variable.type != 'choice' or variable.default is None:
+            if variable.type is None and variable.choices:
+                # choice type inference from the `choices` attribute
+                variable.type = "choice"
+            if variable.choices is not None and variable.type != 'choice':
+                msg = _(f'the variable "{variable.path}" has choices attribut but has not the "choice" type')
+                raise DictConsistencyError(msg, 11, variable.xmlfiles)
+            if variable.type != 'choice':
                 continue
+            if variable.default is None:
+                continue
+            if None in variable.choices and variable.mandatory is None:
+                variable.mandatory = False
             if not isinstance(variable.choices, list):
                 continue
             choices = variable.choices

src/rougail/config.py

@@ -193,7 +193,7 @@ def get_rougail_config(*,
         main_namespace_default = 'rougail'
     else:
         main_namespace_default = 'null'
-    rougail_options = """default_dictionary_format_version:
+    rougail_options = f"""default_dictionary_format_version:
   description: Dictionary format version by default, if not specified in dictionary file
   alternative_name: v
   choices:
@@ -219,7 +219,7 @@ sort_dictionaries_all:
 
 main_namespace:
   description: Main namespace name
-  default: MAIN_MAMESPACE_DEFAULT
+  default: {main_namespace_default}
   alternative_name: s
   mandatory: false
 
@@ -289,18 +289,29 @@ functions_files:
 
 modes_level:
   description: All modes level available
+  multi: true
+  mandatory: false
+"""
+    if backward_compatibility:
+        rougail_options += """
   default:
     - basic
     - standard
     - advanced
-  commandline: false
+"""
-
+    rougail_options += """
 default_family_mode:
   description: Default mode for a family
   default:
-    type: jinja
     jinja: |
+      {% if modes_level %}
       {{ modes_level[0] }}
+      {% endif %}
+  disabled:
+    jinja: |
+      {% if not modes_level %}
+      No mode
+      {% endif %}
   validators:
     - type: jinja
       jinja: |
@@ -312,9 +323,19 @@ default_family_mode:
 default_variable_mode:
   description: Default mode for a variable
   default:
-    type: jinja
     jinja: |
+      {% if modes_level %}
+        {% if modes_level | length == 1 %}
+      {{ modes_level[0] }}
+        {% else %}
       {{ modes_level[1] }}
+        {% endif %}
+      {% endif %}
+  disabled:
+    jinja: |
+      {% if not modes_level %}
+      No mode
+      {% endif %}
   validators:
     - type: jinja
       jinja: |
@@ -364,7 +385,7 @@ suffix:
   default: ''
   mandatory: false
   commandline: false
-""".replace('MAIN_MAMESPACE_DEFAULT', main_namespace_default)
+"""
     processes = {'structural': [],
                  'output': [],
                  'user data': [],

src/rougail/convert.py

@@ -133,7 +133,7 @@ class Paths:
         if not force and is_dynamic:
             self._dynamics[path] = dynamic
 
-    def get_relative_path(self,
+    def get_full_path(self,
                           path: str,
                           current_path: str,
                           ):
@@ -148,21 +148,22 @@ class Paths:
     def get_with_dynamic(
         self,
         path: str,
-        suffix_path: str,
+        identifier_path: str,
         current_path: str,
         version: str,
         namespace: str,
         xmlfiles: List[str],
     ) -> Any:
-        suffix = None
+        identifier = None
         if version != '1.0' and self.regexp_relative.search(path):
-            path = self.get_relative_path(path,
+            path = self.get_full_path(path,
                                       current_path,
                                       )
         else:
-            path = get_realpath(path, suffix_path)
+            path = get_realpath(path, identifier_path)
         dynamic = None
-        if not path in self._data and "{{ suffix }}" not in path:
+        # version 1.0
+        if version == "1.0" and not path in self._data and "{{ identifier }}" not in path:
             new_path = None
             current_path = None
             for name in path.split("."):
@@ -184,10 +185,9 @@ class Paths:
                         parent_dynamic = None
                         name_dynamic = dynamic_path
                     if (
-                        version == "1.0"
+                        parent_dynamic == parent_path
-                        and parent_dynamic == parent_path
+                        and name_dynamic.endswith("{{ identifier }}")
-                        and name_dynamic.endswith("{{ suffix }}")
+                        and name == name_dynamic.replace("{{ identifier }}", "")
-                        and name == name_dynamic.replace("{{ suffix }}", "")
                     ):
                         new_path += "." + name_dynamic
                         break
@@ -197,12 +197,12 @@ class Paths:
                     else:
                         new_path = name
             path = new_path
-        if not path in self._data:
+        if version != "1.0" and not path in self._data:
             current_path = None
+            parent_path = None
             new_path = current_path
-            suffixes = []
+            identifiers = []
             for name in path.split("."):
-                parent_path = current_path
                 if current_path:
                     current_path += "." + name
                 else:
@@ -213,6 +213,7 @@ class Paths:
                         new_path += "." + name
                     else:
                         new_path = name
+                    parent_path = current_path
                     continue
                 for dynamic_path in self._dynamics:
                     if '.' in dynamic_path:
@@ -221,30 +222,35 @@ class Paths:
                         parent_dynamic = None
                         name_dynamic = dynamic_path
                     if (
-                        "{{ suffix }}" not in name_dynamic
+                        "{{ identifier }}" not in name_dynamic
                         or parent_path != parent_dynamic
                     ):
                         continue
-                    regexp = "^" + name_dynamic.replace("{{ suffix }}", "(.*)")
+                    regexp = "^" + name_dynamic.replace("{{ identifier }}", "(.*)")
                     finded = findall(regexp, name)
                     if len(finded) != 1 or not finded[0]:
                         continue
-                    suffixes.append(finded[0])
+                    if finded[0] == "{{ identifier }}":
+                        identifiers.append(None)
+                    else:
+                        identifiers.append(finded[0])
                     if new_path is None:
                         new_path = name_dynamic
                     else:
                         new_path += "." + name_dynamic
+                    parent_path = dynamic_path
                     break
                 else:
                     if new_path:
                         new_path += "." + name
                     else:
                         new_path = name
-                    if "{{ suffix }}" in name:
+                    if "{{ identifier }}" in name:
-                        suffixes.append(None)
+                        identifiers.append(None)
+                    parent_path = current_path
             path = new_path
         else:
-            suffixes = None
+            identifiers = None
         if path not in self._data:
             return None, None
         option = self._data[path]
@@ -258,7 +264,7 @@ class Paths:
                 f'shall not be used in the "{namespace}" namespace'
             )
             raise DictConsistencyError(msg, 38, xmlfiles)
-        return option, suffixes
+        return option, identifiers
 
     def __getitem__(
         self,
@@ -316,8 +322,8 @@ class Informations:
 
 class ParserVariable:
     def __init__(self, rougailconfig):
-        self.load_config(rougailconfig)
         self.rougailconfig = rougailconfig
+        self.load_config()
         self.paths = Paths(self.main_namespace)
         self.families = []
         self.variables = []
@@ -342,12 +348,14 @@ class ParserVariable:
         self.is_init = False
         super().__init__()
 
-    def load_config(self,
+    def load_config(self) -> None:
-                    rougailconfig: 'RougailConfig',
+        rougailconfig = self.rougailconfig
-                    ) -> None:
+        self.sort_dictionaries_all = rougailconfig['sort_dictionaries_all'] 
-        self.rougailconfig = rougailconfig
+        try:
-        self.main_namespace = rougailconfig["main_namespace"]
             self.main_dictionaries = rougailconfig["main_dictionaries"]
+        except:
+            self.main_dictionaries = []
+        self.main_namespace = rougailconfig["main_namespace"]
         if self.main_namespace:
             self.extra_dictionaries = rougailconfig["extra_dictionaries"]
         self.suffix = rougailconfig["suffix"]
@@ -355,6 +363,7 @@ class ParserVariable:
         self.custom_types = rougailconfig["custom_types"]
         self.functions_files = rougailconfig["functions_files"]
         self.modes_level = rougailconfig["modes_level"]
+        if self.modes_level:
             self.default_variable_mode = rougailconfig["default_variable_mode"]
             self.default_family_mode = rougailconfig["default_family_mode"]
         self.extra_annotators = rougailconfig["extra_annotators"]
@@ -362,7 +371,7 @@ class ParserVariable:
         self.export_with_import = rougailconfig["export_with_import"]
         self.internal_functions = rougailconfig["internal_functions"]
         self.add_extra_options = rougailconfig["structural_commandline.add_extra_options"]
-        self.plugins = []
+        self.plugins = rougailconfig["plugins"]
 
     def _init(self):
         if self.is_init:
@@ -557,8 +566,10 @@ class ParserVariable:
             # it's just for modify subfamily or subvariable, do not redefine
             if family_obj:
                 if not obj.pop("redefine", False):
-                    raise Exception(
+                    raise DictConsistencyError(
-                        f"The family {path} already exists and she is not redefined in {filename}"
+                        f'The family "{path}" already exists and it is not redefined',
+                        32,
+                        [filename],
                     )
                 # convert to Calculation objects
                 self.parse_parameters(
@@ -604,12 +615,12 @@ class ParserVariable:
             if obj_type == "dynamic":
                 family_is_dynamic = True
                 parent_dynamic = path
-                if '{{ suffix }}' not in name:
+                if '{{ identifier }}' not in name:
                     if "variable" in family_obj:
-                        name += '{{ suffix }}'
+                        name += '{{ identifier }}'
-                        path += '{{ suffix }}'
+                        path += '{{ identifier }}'
                     else:
-                        msg = f'dynamic family name must have "{{{{ suffix }}}}" in his name for "{path}"'
+                        msg = f'dynamic family name must have "{{{{ identifier }}}}" in his name for "{path}"'
                         raise DictConsistencyError(msg, 13, [filename])
             if version != '1.0' and not family_obj and comment:
                 family_obj['description'] = comment
@@ -938,6 +949,7 @@ class ParserVariable:
 
         variable["namespace"] = self.namespace
         variable["version"] = version
+        variable["path_prefix"] = self.path_prefix
         variable["xmlfiles"] = filename
         variable_type = self.get_family_or_variable_type(variable)
         obj = {
@@ -1074,8 +1086,8 @@ class ParserVariable:
                 try:
                     params.append(PARAM_TYPES[param_typ](**val))
                 except ValidationError as err:
-                    raise Exception(
+                    raise DictConsistencyError(
-                        f'"{attribute}" has an invalid "{key}" for {path}: {err}'
+                        f'"{attribute}" has an invalid "{key}" for {path}: {err}', 29, xmlfiles
                     ) from err
             calculation_object["params"] = params
         #
@@ -1086,8 +1098,8 @@ class ParserVariable:
                     f'unknown "return_type" in {attribute} of variable "{path}"'
                 )
         #
-        if typ == "suffix" and not family_is_dynamic:
+        if typ == "identifier" and not family_is_dynamic:
-            msg = f'suffix calculation for "{attribute}" in "{path}" cannot be set none dynamic family'
+            msg = f'identifier calculation for "{attribute}" in "{path}" cannot be set none dynamic family'
             raise DictConsistencyError(msg, 53, xmlfiles)
         if attribute in PROPERTY_ATTRIBUTE:
             calc = CALCULATION_PROPERTY_TYPES[typ](**calculation_object)
@@ -1143,15 +1155,16 @@ class RougailConvert(ParserVariable):
         """Parse directories content"""
         self._init()
         if path_prefix:
-            if path_prefix in self.parents:
+            n_path_prefix = normalize_family(path_prefix)
+            if n_path_prefix in self.parents:
                 raise Exception("pfffff")
-            root_parent = path_prefix
+            root_parent = n_path_prefix
-            self.path_prefix = path_prefix
+            self.path_prefix = n_path_prefix
             self.namespace = None
             self.add_family(
-                path_prefix,
+                n_path_prefix,
-                path_prefix,
+                n_path_prefix,
-                {},
+                {'description': path_prefix},
                 "",
                 False,
                 None,
@@ -1267,10 +1280,13 @@ class RougailConvert(ParserVariable):
         """Sort filename"""
         if not isinstance(directories, list):
             directories = [directories]
+        if self.sort_dictionaries_all:
+            filenames = {}
         for directory_name in directories:
             directory = Path(directory_name)
             if not directory.is_dir():
                 continue
+            if not self.sort_dictionaries_all:
                 filenames = {}
             for file_path in directory.iterdir():
                 if file_path.suffix not in [".yml", ".yaml"]:
@@ -1282,6 +1298,10 @@ class RougailConvert(ParserVariable):
                         [filenames[file_path.name][1]],
                     )
                 filenames[file_path.name] = str(file_path)
+            if not self.sort_dictionaries_all:
+                for filename in sorted(filenames):
+                    yield filenames[filename]
+        if self.sort_dictionaries_all:
             for filename in sorted(filenames):
                 yield filenames[filename]
 

src/rougail/object_model.py

@@ -137,16 +137,16 @@ class VariableParam(Param):
     optional: bool = False
 
 
-class SuffixParam(Param):
+class IdentifierParam(Param):
     type: str
-    suffix: Optional[int] = None
+    identifier: Optional[int] = None
 
     def __init__(
         self,
         **kwargs,
     ) -> None:
         if not kwargs["family_is_dynamic"]:
-            msg = f'suffix parameter for "{kwargs["attribute"]}" in "{kwargs["path"]}" cannot be set none dynamic family'
+            msg = f'identifier parameter for "{kwargs["attribute"]}" in "{kwargs["path"]}" cannot be set none dynamic family'
             raise DictConsistencyError(msg, 10, kwargs["xmlfiles"])
         super().__init__(**kwargs)
 
@@ -174,7 +174,7 @@ class IndexParam(Param):
 PARAM_TYPES = {
     "any": AnyParam,
     "variable": VariableParam,
-    "suffix": SuffixParam,
+    "identifier": IdentifierParam,
     "information": InformationParam,
     "index": IndexParam,
 }
@@ -209,7 +209,7 @@ class Calculation(BaseModel):
                     path = self.path
                 else:
                     path = self.ori_path
-                variable, suffix = objectspace.paths.get_with_dynamic(
+                variable, identifier = objectspace.paths.get_with_dynamic(
                     param["variable"],
                     self.path_prefix,
                     path,
@@ -225,15 +225,15 @@ class Calculation(BaseModel):
                 if not isinstance(variable, objectspace.variable):
                     raise Exception("pfff it's a family")
                 param["variable"] = variable
-                if suffix:
+                if identifier:
-                    param["suffix"] = suffix
+                    param["identifier"] = identifier
             if param.get("type") == "information":
                 if param["variable"]:
                     if self.ori_path is None:
                         path = self.path
                     else:
                         path = self.ori_path
-                    variable, suffix = objectspace.paths.get_with_dynamic(
+                    variable, identifier = objectspace.paths.get_with_dynamic(
                         param["variable"],
                         self.path_prefix,
                         path,
@@ -245,7 +245,7 @@ class Calculation(BaseModel):
                         msg = f'cannot find variable "{param["variable"]}" defined in "{self.attribute_name}" for "{self.path}"'
                         raise DictConsistencyError(msg, 14, self.xmlfiles)
                     param["variable"] = variable
-                    if suffix:
+                    if identifier:
                         msg = f'variable "{param["variable"]}" defined in "{self.attribute_name}" for "{self.path}" is a dynamic variable'
                         raise DictConsistencyError(msg, 15, self.xmlfiles)
                 else:
@@ -311,7 +311,7 @@ class JinjaCalculation(Calculation):
             path = self.path
         else:
             path = self.ori_path
-        for sub_variable, suffix, true_path in get_jinja_variable_to_param(
+        for sub_variable, identifier, true_path in get_jinja_variable_to_param(
             path,
             self.jinja,
             objectspace,
@@ -333,8 +333,8 @@ class JinjaCalculation(Calculation):
                     "type": "variable",
                     "variable": sub_variable,
                 }
-                if suffix:
+                if identifier:
-                    default["params"][true_path]["suffix"] = suffix
+                    default["params"][true_path]["identifier"] = identifier
         return default
 
     def to_function(
@@ -410,7 +410,7 @@ class _VariableCalculation(Calculation):
             path = self.path
         else:
             path = self.ori_path
-        variable, suffix = objectspace.paths.get_with_dynamic(
+        variable, identifier = objectspace.paths.get_with_dynamic(
             self.variable,
             self.path_prefix,
             path,
@@ -421,13 +421,13 @@ class _VariableCalculation(Calculation):
         if variable and not isinstance(variable, objectspace.variable):
             # FIXME remove the pfff
             raise Exception("pfff it's a family")
-        return variable, suffix
+        return variable, identifier
 
     def get_params(
         self,
         objectspace,
         variable: "Variable",
-        suffix: Optional[str],
+        identifier: Optional[str],
         *,
         needs_multi: Optional[bool] = None,
     ):
@@ -439,8 +439,8 @@ class _VariableCalculation(Calculation):
             "variable": variable,
             "propertyerror": self.propertyerror,
         }
-        if suffix:
+        if identifier:
-            param["suffix"] = suffix
+            param["identifier"] = identifier
         params = {None: [param]}
         if self.default_values:
             params["__default_value"] = self.default_values
@@ -454,7 +454,7 @@ class _VariableCalculation(Calculation):
         calc_variable_is_multi = variable.path in objectspace.multis
         if not calc_variable_is_multi:
             if variable.path in objectspace.paths._dynamics and (
-                suffix is None or suffix[-1] is None
+                identifier is None or identifier[-1] is None
             ):
                 self_dyn_path = objectspace.paths._dynamics.get(self.path)
                 if self_dyn_path is not None:
@@ -465,7 +465,7 @@ class _VariableCalculation(Calculation):
                         calc_variable_is_multi = True
                 else:
                     calc_variable_is_multi = True
-            elif suffix and '{{ suffix }}' in suffix:
+            elif identifier and '{{ identifier }}' in identifier:
                 calc_variable_is_multi = True
         if needs_multi:
             if calc_variable_is_multi:
@@ -499,12 +499,12 @@ class VariableCalculation(_VariableCalculation):
         if self.attribute_name != "default" and self.optional:
             msg = f'"{self.attribute_name}" variable shall not have an "optional" attribute for variable "{self.variable}"'
             raise DictConsistencyError(msg, 33, self.xmlfiles)
-        variable, suffix = self.get_variable(objectspace)
+        variable, identifier = self.get_variable(objectspace)
         if not variable and self.optional:
             raise VariableCalculationDependencyError()
         params = self.get_params(objectspace,
                                  variable,
-                                 suffix,
+                                 identifier,
                                  )
         return {
             "function": "calc_value",
@@ -521,10 +521,10 @@ class VariablePropertyCalculation(_VariableCalculation):
         self,
         objectspace,
     ) -> dict:
-        variable, suffix = self.get_variable(objectspace)
+        variable, identifier = self.get_variable(objectspace)
         params = self.get_params(objectspace,
                                  variable,
-                                 suffix,
+                                 identifier,
                                  needs_multi=False,)
         variable = params[None][0]["variable"]
         if self.when is not undefined:
@@ -579,7 +579,7 @@ class InformationCalculation(Calculation):
                 path = self.path
             else:
                 path = self.ori_path
-            variable, suffix = objectspace.paths.get_with_dynamic(
+            variable, identifier = objectspace.paths.get_with_dynamic(
                 self.variable,
                 self.path_prefix,
                 path,
@@ -587,7 +587,7 @@ class InformationCalculation(Calculation):
                 self.namespace,
                 self.xmlfiles,
             )
-            if variable is None or suffix is not None:
+            if variable is None or identifier is not None:
                 raise Exception("pfff")
             params[None][0]["variable"] = variable
         if self.default_values:
@@ -598,33 +598,33 @@ class InformationCalculation(Calculation):
         }
 
 
-class _SuffixCalculation(Calculation):
+class _IdentifierCalculation(Calculation):
-    suffix: Optional[int] = None
+    identifier: Optional[int] = None
 
-    def get_suffix(self) -> dict:
+    def get_identifier(self) -> dict:
-        suffix = {"type": "suffix"}
+        identifier = {"type": "identifier"}
-        if self.suffix is not None:
+        if self.identifier is not None:
-            suffix["suffix"] = self.suffix
+            identifier["identifier"] = self.identifier
-        return suffix
+        return identifier
 
 
-class SuffixCalculation(_SuffixCalculation):
+class IdentifierCalculation(_IdentifierCalculation):
     attribute_name: Literal["default", "choice", "dynamic"]
 
     def to_function(
         self,
         objectspace,
     ) -> dict:
-        suffix = {"type": "suffix"}
+        identifier = {"type": "identifier"}
-        if self.suffix is not None:
+        if self.identifier is not None:
-            suffix["suffix"] = self.suffix
+            identifier["identifier"] = self.identifier
         return {
             "function": "calc_value",
-            "params": {None: [self.get_suffix()]},
+            "params": {None: [self.get_identifier()]},
         }
 
 
-class SuffixPropertyCalculation(_SuffixCalculation):
+class IdentifierPropertyCalculation(_IdentifierCalculation):
     attribute_name: Literal[*PROPERTY_ATTRIBUTE]
     when: Any = undefined
     when_not: Any = undefined
@@ -638,7 +638,7 @@ class SuffixPropertyCalculation(_SuffixCalculation):
             raise DictConsistencyError(msg, 105, variable.xmlfiles)
         if self.when is not undefined:
             if self.when_not is not undefined:
-                msg = f'the suffix has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
+                msg = f'the identifier has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
                 raise DictConsistencyError(msg, 35, variable.xmlfiles)
             when = self.when
             inverse = False
@@ -646,9 +646,9 @@ class SuffixPropertyCalculation(_SuffixCalculation):
             when = self.when_not
             inverse = True
         else:
-            msg = f'the suffix has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
+            msg = f'the identifier has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
             raise DictConsistencyError
-        params = {None: [self.attribute_name, self.get_suffix()],
+        params = {None: [self.attribute_name, self.get_identifier()],
                   "when": when,
                   "inverse": inverse,
                   }
@@ -679,14 +679,14 @@ CALCULATION_TYPES = {
     "jinja": JinjaCalculation,
     "variable": VariableCalculation,
     "information": InformationCalculation,
-    "suffix": SuffixCalculation,
+    "identifier": IdentifierCalculation,
     "index": IndexCalculation,
 }
 CALCULATION_PROPERTY_TYPES = {
     "jinja": JinjaCalculation,
     "variable": VariablePropertyCalculation,
     "information": InformationCalculation,
-    "suffix": SuffixPropertyCalculation,
+    "identifier": IdentifierPropertyCalculation,
     "index": IndexCalculation,
 }
 BASETYPE_CALC = Union[StrictBool, StrictInt, StrictFloat, StrictStr, Calculation, None]
@@ -729,7 +729,7 @@ class Variable(BaseModel):
     help: Optional[str] = None
     hidden: Union[bool, Calculation] = False
     disabled: Union[bool, Calculation] = False
-    mandatory: Union[None, bool, Calculation] = True
+    mandatory: Union[None, bool, Calculation] = None
     empty: Union[None, bool, Calculation] = True
     auto_save: bool = False
     mode: Optional[str] = None

src/rougail/tiramisu.py

@@ -138,35 +138,36 @@ func['valid_with_jinja'] = valid_with_jinja
 
 
 class ConvertDynOptionDescription(DynOptionDescription):
-    """Suffix could be an integer, we should convert it in str
+    """Identifier could be an integer, we should convert it in str
-    Suffix could also contain invalid character, so we should "normalize" it
+    Identifier could also contain invalid character, so we should "normalize" it
     """
 
-    def convert_suffix_to_path(self, suffix):
+    def convert_identifier_to_path(self, identifier):
-        if suffix is None:
+        if identifier is None:
-            return suffix
+            return identifier
-        if not isinstance(suffix, str):
+        if not isinstance(identifier, str):
-            suffix = str(suffix)
+            identifier = str(identifier)
-        return normalize_family(suffix)
+        return normalize_family(identifier)
 
     def impl_getname(
         self,
-        suffix=None,
+        identifier=None,
     ) -> str:
         """get name"""
         name = super().impl_getname(None)
-        if suffix is None:
+        if identifier is None:
             return name
-        path_suffix = self.convert_suffix_to_path(suffix)
+        path_identifier = self.convert_identifier_to_path(identifier)
-        if "{{ suffix }}" in name:
+        if "{{ identifier }}" in name:
-            return name.replace("{{ suffix }}", path_suffix)
+            return name.replace("{{ identifier }}", path_identifier)
-        return name + path_suffix
+        return name + path_identifier
 
     def impl_get_display_name(
         self,
         subconfig,
+        with_quote: bool=False,
         ) -> str:
-        display = super().impl_get_display_name(subconfig)
+        display = super().impl_get_display_name(subconfig, with_quote=with_quote)
-        if "{{ suffix }}" in display:
+        if "{{ identifier }}" in display:
-            return display.replace("{{ suffix }}", self.convert_suffix_to_path(self.get_suffixes(subconfig)[-1]))
+            return display.replace("{{ identifier }}", self.convert_identifier_to_path(self.get_identifiers(subconfig)[-1]))
         return display

src/rougail/tiramisureflector.py

@@ -89,6 +89,12 @@ class TiramisuReflector:
                     continue
                 self.text["header"].append(f"load_functions('{funcs_path}')")
         if self.objectspace.export_with_import:
+            if objectspace.main_namespace:
+                self.text["header"].extend(["try:",
+                                            "    groups.namespace",
+                                            "except:",
+                                            "    groups.addgroup('namespace')",
+                                            ])
             for mode in self.objectspace.modes_level:
                 self.text["header"].append(f'ALLOWED_LEADER_PROPERTIES.add("{mode}")')
         self.make_tiramisu_objects()
@@ -322,17 +328,17 @@ class Common:
                     information_variable.informations.append(information_name)
                     return information_name
             return f'ParamInformation("{param["information"]}", {default})'
-        if param["type"] == "suffix":
+        if param["type"] == "identifier":
-            if "suffix" in param and param["suffix"] != None:
+            if "identifier" in param and param["identifier"] != None:
-                return f"ParamSuffix(suffix_index={param['suffix']})"
+                return f"ParamIdentifier(identifier_index={param['identifier']})"
-            return "ParamSuffix()"
+            return "ParamIdentifier()"
         if param["type"] == "index":
             return "ParamIndex()"
         if param["type"] == "variable":
             return self.build_option_param(
                 param["variable"],
                 param.get("propertyerror", True),
-                param.get("suffix"),
+                param.get("identifier"),
                 param.get("dynamic"),
                 param.get('whole', False),
             )
@@ -348,7 +354,7 @@ class Common:
         self,
         variable,
         propertyerror,
-        suffix: Optional[str],
+        identifier: Optional[str],
         dynamic,
         whole: bool,
     ) -> str:
@@ -362,9 +368,14 @@ class Common:
             self.calls, self.elt.path
         )
         params = [f"{option_name}"]
-        if suffix is not None:
+        if identifier is not None:
             param_type = "ParamDynOption"
-            params.append(self.convert_str(suffix))
+            identifiers = []
+            for ident in identifier:
+                if isinstance(ident, str):
+                    ident = self.convert_str(ident)
+                identifiers.append(str(ident))
+            params.append('[' + ', '.join(identifiers) + ']')
         else:
             param_type = "ParamOption"
         if not propertyerror:
@@ -518,6 +529,10 @@ class Family(Common):
             self.object_type = "Leadership"
         else:
             self.object_type = "OptionDescription"
+        if hasattr(self.elt, 'name') and self.elt.name == self.elt.namespace:
+            self.group_type = 'groups.namespace'
+        else:
+            self.group_type = None
         self.children = []
 
     def add(self, child):
@@ -528,8 +543,10 @@ class Family(Common):
         self,
         keys: list,
     ) -> None:
+        if self.group_type:
+            keys["group_type"] = self.group_type
         if self.elt.type == "dynamic":
-            keys["suffixes"] = self.populate_calculation(self.elt.dynamic)
+            keys["identifiers"] = self.populate_calculation(self.elt.dynamic)
         children = []
         for path in self.objectspace.parents[self.elt.path]:
             children.append(self.objectspace.paths[path])

src/rougail/utils.py

@@ -124,7 +124,7 @@ def get_jinja_variable_to_param(
     founded_variables = {}
     unknown_variables = []
     for variable_path in variables:
-        variable, suffix = objectspace.paths.get_with_dynamic(
+        variable, identifier = objectspace.paths.get_with_dynamic(
             variable_path,
             path_prefix,
             current_path,
@@ -133,7 +133,7 @@ def get_jinja_variable_to_param(
             xmlfiles,
         )
         if variable and variable.path in objectspace.variables:
-            founded_variables[variable_path] = (suffix, variable)
+            founded_variables[variable_path] = (identifier, variable)
         else:
             sub_family = variable_path + '.'
             for founded_variable in chain(founded_variables, unknown_variables):
@@ -151,7 +151,7 @@ def get_jinja_variable_to_param(
             vpath = variable_path
             while '.' in vpath:
                 vpath = vpath.rsplit('.', 1)[0]
-                variable, suffix = objectspace.paths.get_with_dynamic(
+                variable, identifier = objectspace.paths.get_with_dynamic(
                     vpath,
                     path_prefix,
                     current_path,

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

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

tests/dictionaries/00_0empty/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="version", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_0version_underscore/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="version", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_6 = StrOption(name="version", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"basic"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"basic"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="empty", doc="empty", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_1empty_variable/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="empty", doc="empty", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_6 = StrOption(name="empty", doc="empty", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"basic"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"basic"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,11 +3,15 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_rougail.var2'] = "{{ _.var1 }}\n"
 option_2 = StrOption(name="var1", doc="a first variable", default="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_2default_calculated/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.var2"), '_.var1': ParamOption(option_2)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_2default_calculated/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -10,10 +14,10 @@ dict_env['default_1.rougail.var2'] = "{{ _.var1 }}\n"
 dict_env['default_2.rougail.var2'] = "{{ _.var1 }}\n"
 option_3 = StrOption(name="var1", doc="a first variable", default="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_2default_calculated/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.var2"), '_.var1': ParamOption(option_3)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_7 = StrOption(name="var1", doc="a first variable", default="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_8 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_2default_calculated/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.var2"), '_.var1': ParamOption(option_7)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,11 +3,15 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_rougail.var2'] = "{% for val in _.var1 %}\n{{ val }}\n{% endfor %}\n"
 option_2 = StrOption(name="var1", doc="a first variable", multi=True, default=["no", "yes", "maybe"], default_multi="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_2default_calculated_multi/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.var2"), '_.var1': ParamOption(option_2)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_2default_calculated_multi/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -10,10 +14,10 @@ dict_env['default_1.rougail.var2'] = "{% for val in _.var1 %}\n{{ val }}\n{% end
 dict_env['default_2.rougail.var2'] = "{% for val in _.var1 %}\n{{ val }}\n{% endfor %}\n"
 option_3 = StrOption(name="var1", doc="a first variable", multi=True, default=["no", "yes", "maybe"], default_multi="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_2default_calculated_multi/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.var2"), '_.var1': ParamOption(option_3)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_7 = StrOption(name="var1", doc="a first variable", multi=True, default=["no", "yes", "maybe"], default_multi="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_8 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_2default_calculated_multi/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.var2"), '_.var1': ParamOption(option_7)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'domainname'})
 option_3 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_2)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_2default_calculated_variable_transitive/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'domainname'})
 option_4 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_3)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_7 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'domainname'})
 option_8 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_7)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="var1", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_3 = StrOption(name="var2", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_4load_subfolder/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="var1", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_4 = StrOption(name="var2", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_7 = StrOption(name="var1", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_8 = StrOption(name="var2", doc="a variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="without_type", doc="a variable", default="non", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_5load_notype/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="without_type", doc="a variable", default="non", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="without_type", doc="a variable", default="non", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,5 +16,5 @@ option_4 = BoolOption(name="var3", doc="the third variable", default=True, prope
 option_5 = BoolOption(name="var4", doc="the forth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
 option_6 = BoolOption(name="var5", doc="the fifth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
 option_7 = BoolOption(name="var6", doc="the sixth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6boolean/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,7 +16,7 @@ option_5 = BoolOption(name="var3", doc="the third variable", default=True, prope
 option_6 = BoolOption(name="var4", doc="the forth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
 option_7 = BoolOption(name="var5", doc="the fifth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
 option_8 = BoolOption(name="var6", doc="the sixth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_11 = BoolOption(name="var1", doc="the first variable", default=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
 option_12 = BoolOption(name="var2", doc="the second variable", default=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
@@ -20,6 +24,6 @@ option_13 = BoolOption(name="var3", doc="the third variable", default=True, prop
 option_14 = BoolOption(name="var4", doc="the forth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
 option_15 = BoolOption(name="var5", doc="the fifth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
 option_16 = BoolOption(name="var6", doc="the sixth variable", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean'})
-optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"standard"}))
+optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"standard"}))
 optiondescription_9 = OptionDescription(name="2", doc="2", children=[optiondescription_10], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_9])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = BoolOption(name="variable", doc="a variable", default=True, properties=frozenset({"standard"}), informations={'type': 'boolean'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6boolean_no_mandatory/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = BoolOption(name="variable", doc="a variable", default=True, properties=frozenset({"standard"}), informations={'type': 'boolean'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = BoolOption(name="variable", doc="a variable", default=True, properties=frozenset({"standard"}), informations={'type': 'boolean'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,5 +16,5 @@ option_4 = ChoiceOption(name="var3", doc="the third variable", values=("a", "b",
 option_5 = ChoiceOption(name="var4", doc="the forth variable", values=(None, "b", "c"), properties=frozenset({"standard"}), informations={'type': 'choice'})
 option_6 = ChoiceOption(name="var5", doc="the fifth variable", values=("a", "b", "c"), default="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
 option_7 = ChoiceOption(name="var6", doc="the sixth variable", values=(1, 2, 3), default=1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6choice/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,7 +16,7 @@ option_5 = ChoiceOption(name="var3", doc="the third variable", values=("a", "b",
 option_6 = ChoiceOption(name="var4", doc="the forth variable", values=(None, "b", "c"), properties=frozenset({"standard"}), informations={'type': 'choice'})
 option_7 = ChoiceOption(name="var5", doc="the fifth variable", values=("a", "b", "c"), default="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
 option_8 = ChoiceOption(name="var6", doc="the sixth variable", values=(1, 2, 3), default=1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_11 = ChoiceOption(name="var1", doc="the first variable", values=("a", "b", "c"), properties=frozenset({"basic", "mandatory"}), informations={'type': 'choice'})
 option_12 = ChoiceOption(name="var2", doc="the second variable", values=("a", "b", "c"), properties=frozenset({"basic", "mandatory"}), informations={'type': 'choice'})
@@ -20,6 +24,6 @@ option_13 = ChoiceOption(name="var3", doc="the third variable", values=("a", "b"
 option_14 = ChoiceOption(name="var4", doc="the forth variable", values=(None, "b", "c"), properties=frozenset({"standard"}), informations={'type': 'choice'})
 option_15 = ChoiceOption(name="var5", doc="the fifth variable", values=("a", "b", "c"), default="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
 option_16 = ChoiceOption(name="var6", doc="the sixth variable", values=(1, 2, 3), default=1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"basic"}))
+optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"basic"}))
 optiondescription_9 = OptionDescription(name="2", doc="2", children=[optiondescription_10], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_9])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['choices_rougail.var'] = "{% for n in trange(0, 10) %}\n{{ n }}\n{% endfor %}\n"
 option_2 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_rougail.var"), '__internal_type': ParamValue("number"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_6choice_calculation/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("choices"), '__internal_variable': ParamValue("rougail.var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6choice_calculation/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['choices_1.rougail.var'] = "{% for n in trange(0, 10) %}\n{{ n }}\n{% endfor %}\n"
 dict_env['choices_2.rougail.var'] = "{% for n in trange(0, 10) %}\n{{ n }}\n{% endfor %}\n"
 option_3 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_1.rougail.var"), '__internal_type': ParamValue("number"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_6choice_calculation/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("choices"), '__internal_variable': ParamValue("1.rougail.var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_2.rougail.var"), '__internal_type': ParamValue("number"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_6choice_calculation/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("choices"), '__internal_variable': ParamValue("2.rougail.var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="var1", doc="a second variable", multi=True, default=["a", "b", "c"], default_multi="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = ChoiceOption(name="var2", doc="a first variable", values=Calculation(func['calc_value'], Params((ParamOption(option_2)))), default="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6choice_variable/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="var1", doc="a second variable", multi=True, default=["a", "b", "c"], default_multi="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = ChoiceOption(name="var2", doc="a first variable", values=Calculation(func['calc_value'], Params((ParamOption(option_3)))), default="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_7 = StrOption(name="var1", doc="a second variable", multi=True, default=["a", "b", "c"], default_multi="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_8 = ChoiceOption(name="var2", doc="a first variable", values=Calculation(func['calc_value'], Params((ParamOption(option_7)))), default="a", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = CustomOption(name="custom1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'custom'})
 option_3 = CustomOption(name="custom2", doc="the seconf variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'custom'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6custom/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = CustomOption(name="custom1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'custom'})
 option_4 = CustomOption(name="custom2", doc="the seconf variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'custom'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_7 = CustomOption(name="custom1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'custom'})
 option_8 = CustomOption(name="custom2", doc="the seconf variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'custom'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = DomainnameOption(name="variable", doc="a domain name variable", default="my.domain.name", type="domainname", allow_ip=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6domainname/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = DomainnameOption(name="variable", doc="a domain name variable", default="my.domain.name", type="domainname", allow_ip=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = DomainnameOption(name="variable", doc="a domain name variable", default="my.domain.name", type="domainname", allow_ip=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = DomainnameOption(name="variable", doc="a domain name variable", default="my.domain.name", type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6domainname_params/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = DomainnameOption(name="variable", doc="a domain name variable", default="my.domain.name", type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = DomainnameOption(name="variable", doc="a domain name variable", default="my.domain.name", type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,5 +16,5 @@ option_4 = FloatOption(name="var3", doc="the third variable", default=0.0, prope
 option_5 = FloatOption(name="var4", doc="the forth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
 option_6 = FloatOption(name="var5", doc="the fifth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
 option_7 = FloatOption(name="var6", doc="the sixth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6float/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,7 +16,7 @@ option_5 = FloatOption(name="var3", doc="the third variable", default=0.0, prope
 option_6 = FloatOption(name="var4", doc="the forth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
 option_7 = FloatOption(name="var5", doc="the fifth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
 option_8 = FloatOption(name="var6", doc="the sixth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_11 = FloatOption(name="var1", doc="the first variable", default=0.0, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
 option_12 = FloatOption(name="var2", doc="the second variable", default=0.0, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
@@ -20,6 +24,6 @@ option_13 = FloatOption(name="var3", doc="the third variable", default=0.0, prop
 option_14 = FloatOption(name="var4", doc="the forth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
 option_15 = FloatOption(name="var5", doc="the fifth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
 option_16 = FloatOption(name="var6", doc="the sixth variable", default=10.1, properties=frozenset({"mandatory", "standard"}), informations={'type': 'float'})
-optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"standard"}))
+optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"standard"}))
 optiondescription_9 = OptionDescription(name="2", doc="2", children=[optiondescription_10], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_9])

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

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,5 +16,5 @@ option_4 = IntOption(name="var3", doc="the third variable", default=0, propertie
 option_5 = IntOption(name="var4", doc="this forth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
 option_6 = IntOption(name="var5", doc="the fifth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
 option_7 = IntOption(name="var6", doc="the sixth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6number/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,7 +16,7 @@ option_5 = IntOption(name="var3", doc="the third variable", default=0, propertie
 option_6 = IntOption(name="var4", doc="this forth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
 option_7 = IntOption(name="var5", doc="the fifth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
 option_8 = IntOption(name="var6", doc="the sixth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_11 = IntOption(name="var1", doc="the first variable", default=0, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
 option_12 = IntOption(name="var2", doc="the second variable", default=0, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
@@ -20,6 +24,6 @@ option_13 = IntOption(name="var3", doc="the third variable", default=0, properti
 option_14 = IntOption(name="var4", doc="this forth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
 option_15 = IntOption(name="var5", doc="the fifth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
 option_16 = IntOption(name="var6", doc="the sixth variable", default=10, properties=frozenset({"mandatory", "standard"}), informations={'type': 'number'})
-optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"standard"}))
+optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"standard"}))
 optiondescription_9 = OptionDescription(name="2", doc="2", children=[optiondescription_10], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_9])

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

@@ -3,11 +3,15 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = PortOption(name="variable1", doc="a port variable", allow_private=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'port'})
 option_3 = PortOption(name="variable2", doc="a port variable with default value", default="8080", allow_private=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'port'})
 option_4 = PortOption(name="variable3", doc="a port variable with integer default value", default="8080", allow_private=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'port'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6port/tiramisu/multi.py

@@ -3,17 +3,21 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = PortOption(name="variable1", doc="a port variable", allow_private=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'port'})
 option_4 = PortOption(name="variable2", doc="a port variable with default value", default="8080", allow_private=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'port'})
 option_5 = PortOption(name="variable3", doc="a port variable with integer default value", default="8080", allow_private=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'port'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_8 = PortOption(name="variable1", doc="a port variable", allow_private=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'port'})
 option_9 = PortOption(name="variable2", doc="a port variable with default value", default="8080", allow_private=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'port'})
 option_10 = PortOption(name="variable3", doc="a port variable with integer default value", default="8080", allow_private=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'port'})
-optiondescription_7 = OptionDescription(name="rougail", doc="Rougail", children=[option_8, option_9, option_10], properties=frozenset({"basic"}))
+optiondescription_7 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_8, option_9, option_10], properties=frozenset({"basic"}))
 optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6])

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

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,5 +16,5 @@ class Regexp_option_2(RegexpOption):
 Regexp_option_2._regexp = re_compile(r"^#(?:[0-9a-f]{3}){1,2}$")
 
 option_2 = Regexp_option_2(name="var", doc="a first variable", default="#a1a1a1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'regexp', 'test': ('#b1b1b1', '#b2b2b2')})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6regexp/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -17,9 +21,9 @@ class Regexp_option_6(RegexpOption):
 Regexp_option_6._regexp = re_compile(r"^#(?:[0-9a-f]{3}){1,2}$")
 
 option_3 = Regexp_option_3(name="var", doc="a first variable", default="#a1a1a1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'regexp', 'test': ('#b1b1b1', '#b2b2b2')})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = Regexp_option_6(name="var", doc="a first variable", default="#a1a1a1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'regexp', 'test': ('#b1b1b1', '#b2b2b2')})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,5 +16,5 @@ option_4 = StrOption(name="var3", doc="the third variable", properties=frozenset
 option_5 = StrOption(name="var4", doc="the forth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_6 = StrOption(name="var5", doc="the fifth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_7 = StrOption(name="var6", doc="the sixth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4, option_5, option_6, option_7], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6string/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -12,7 +16,7 @@ option_5 = StrOption(name="var3", doc="the third variable", properties=frozenset
 option_6 = StrOption(name="var4", doc="the forth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_7 = StrOption(name="var5", doc="the fifth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_8 = StrOption(name="var6", doc="the sixth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5, option_6, option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_11 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_12 = StrOption(name="var2", doc="the second variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
@@ -20,6 +24,6 @@ option_13 = StrOption(name="var3", doc="the third variable", properties=frozense
 option_14 = StrOption(name="var4", doc="the forth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_15 = StrOption(name="var5", doc="the fifth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_16 = StrOption(name="var6", doc="the sixth variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"basic"}))
+optiondescription_10 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_11, option_12, option_13, option_14, option_15, option_16], properties=frozenset({"basic"}))
 optiondescription_9 = OptionDescription(name="2", doc="2", children=[optiondescription_10], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_9])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = ChoiceOption(name="var", doc="A choice", values=("quote'", "quote\"", "quote\"'"), default="quote'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_7choice_quote/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = ChoiceOption(name="var", doc="A choice", values=("quote'", "quote\"", "quote\"'"), default="quote'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = ChoiceOption(name="var", doc="A choice", values=("quote'", "quote\"", "quote\"'"), default="quote'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'help': "message with '"})
 option_3 = StrOption(name="var2", doc="the second variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'help': 'message with "'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_7help_quote/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'help': "message with '"})
 option_4 = StrOption(name="var2", doc="the second variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'help': 'message with "'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_7 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'help': "message with '"})
 option_8 = StrOption(name="var2", doc="the second variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'help': 'message with "'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="variable", doc="a variable", default="quote\"", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_7value_doublequote/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="variable", doc="a variable", default="quote\"", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="variable", doc="a variable", default="quote\"", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="variable", doc="a variable", default="quote'\"", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_7value_doublequote2/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="variable", doc="a variable", default="quote'\"", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="variable", doc="a variable", default="quote'\"", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

tests/dictionaries/00_7value_doublequote3/dictionaries/rougail/00-base.yml

@@ -1,6 +1,6 @@
 ---
-version: '1.0'
+version: '1.1'
+
 variable:
   description: a variable
-  hidden: true
   default: quote\"\'

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
-option_2 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"}), informations={'type': 'string'})
+option_2 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_7value_doublequote3/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
-option_3 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"}), informations={'type': 'string'})
+option_3 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
-option_6 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"}), informations={'type': 'string'})
+option_6 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

tests/dictionaries/00_7value_doublequote3/tiramisu/no_namespace.py

@@ -6,5 +6,5 @@ load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
-option_1 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"}), informations={'type': 'string'})
+option_1 = StrOption(name="variable", doc="a variable", default="quote\\\"\\'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="variable", doc="a variable", default="quote'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_7value_quote/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="variable", doc="a variable", default="quote'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="variable", doc="a variable", default="quote'", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_rougail.variable'] = "{{test_information }}\n"
 option_2 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_8calculation_information/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.variable"), 'test_information': ParamInformation("test_information", None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_8calculation_information/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_1.rougail.variable'] = "{{test_information }}\n"
 dict_env['default_2.rougail.variable'] = "{{test_information }}\n"
 option_3 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_8calculation_information/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.variable"), 'test_information': ParamInformation("test_information", None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_8calculation_information/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.variable"), 'test_information': ParamInformation("test_information", None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

tests/dictionaries/00_8test/dictionaries/rougail/00-base.yml

@@ -1,25 +1,31 @@
 ---
 version: '1.1'
+
 var1:
   description: the first variable
   test:
     - test
+
 var2:
   description: the second variable
   test:
     - test
   default: value
+
 var3:
   description: the third variable
   test:
     - test1
     - test2
+
 var4:
   description: the forth variable
   test:
     - null
     - test1
     - test2
+  mandatory: false
+
 var5:
   description: the fifth variable
   type: boolean

tests/dictionaries/00_8test/makedict/mandatory.json

@@ -1 +1 @@
-["rougail.var1", "rougail.var3", "rougail.var4"]
+["rougail.var1", "rougail.var3"]

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

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test',)})
 option_3 = StrOption(name="var2", doc="the second variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string', 'test': ('test',)})
 option_4 = StrOption(name="var3", doc="the third variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test1', 'test2')})
-option_5 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
+option_5 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"standard"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
 option_6 = BoolOption(name="var5", doc="the fifth variable", default=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean', 'test': (False,)})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4, option_5, option_6], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4, option_5, option_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_8test/tiramisu/multi.py

@@ -3,21 +3,25 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test',)})
 option_4 = StrOption(name="var2", doc="the second variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string', 'test': ('test',)})
 option_5 = StrOption(name="var3", doc="the third variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test1', 'test2')})
-option_6 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
+option_6 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"standard"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
 option_7 = BoolOption(name="var5", doc="the fifth variable", default=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean', 'test': (False,)})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5, option_6, option_7], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5, option_6, option_7], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_10 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test',)})
 option_11 = StrOption(name="var2", doc="the second variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string', 'test': ('test',)})
 option_12 = StrOption(name="var3", doc="the third variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test1', 'test2')})
-option_13 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
+option_13 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"standard"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
 option_14 = BoolOption(name="var5", doc="the fifth variable", default=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean', 'test': (False,)})
-optiondescription_9 = OptionDescription(name="rougail", doc="Rougail", children=[option_10, option_11, option_12, option_13, option_14], properties=frozenset({"basic"}))
+optiondescription_9 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_10, option_11, option_12, option_13, option_14], properties=frozenset({"basic"}))
 optiondescription_8 = OptionDescription(name="2", doc="2", children=[optiondescription_9], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_8])

tests/dictionaries/00_8test/tiramisu/no_namespace.py

@@ -9,6 +9,6 @@ ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_1 = StrOption(name="var1", doc="the first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test',)})
 option_2 = StrOption(name="var2", doc="the second variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string', 'test': ('test',)})
 option_3 = StrOption(name="var3", doc="the third variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': ('test1', 'test2')})
-option_4 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
+option_4 = StrOption(name="var4", doc="the forth variable", properties=frozenset({"standard"}), informations={'type': 'string', 'test': (None, 'test1', 'test2')})
 option_5 = BoolOption(name="var5", doc="the fifth variable", default=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean', 'test': (False,)})
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1, option_2, option_3, option_4, option_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = ChoiceOption(name="variable1", doc="a first variable", values=("val1", "val2"), multi=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'choice'})
 option_3 = ChoiceOption(name="variable2", doc="a second variable", values=("val1", "val2"), multi=True, properties=frozenset({"standard"}), informations={'type': 'choice'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9choice_variable_multi/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = ChoiceOption(name="variable1", doc="a first variable", values=("val1", "val2"), multi=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'choice'})
 option_4 = ChoiceOption(name="variable2", doc="a second variable", values=("val1", "val2"), multi=True, properties=frozenset({"standard"}), informations={'type': 'choice'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_7 = ChoiceOption(name="variable1", doc="a first variable", values=("val1", "val2"), multi=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'choice'})
 option_8 = ChoiceOption(name="variable2", doc="a second variable", values=("val1", "val2"), multi=True, properties=frozenset({"standard"}), informations={'type': 'choice'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,11 +3,15 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="source_variable_1", doc="the first source variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = StrOption(name="source_variable_2", doc="the second source variable", default="val2", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = ChoiceOption(name="my_variable", doc="a variable", values=(Calculation(func['calc_value'], Params((ParamOption(option_2)))), Calculation(func['calc_value'], Params((ParamOption(option_3))))), default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3, option_4], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9choice_variables/tiramisu/multi.py

@@ -3,17 +3,21 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="source_variable_1", doc="the first source variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = StrOption(name="source_variable_2", doc="the second source variable", default="val2", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_5 = ChoiceOption(name="my_variable", doc="a variable", values=(Calculation(func['calc_value'], Params((ParamOption(option_3)))), Calculation(func['calc_value'], Params((ParamOption(option_4))))), default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4, option_5], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4, option_5], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_8 = StrOption(name="source_variable_1", doc="the first source variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_9 = StrOption(name="source_variable_2", doc="the second source variable", default="val2", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_10 = ChoiceOption(name="my_variable", doc="a variable", values=(Calculation(func['calc_value'], Params((ParamOption(option_8)))), Calculation(func['calc_value'], Params((ParamOption(option_9))))), default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_7 = OptionDescription(name="rougail", doc="Rougail", children=[option_8, option_9, option_10], properties=frozenset({"standard"}))
+optiondescription_7 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_8, option_9, option_10], properties=frozenset({"standard"}))
 optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_rougail.variable'] = "{{ param1 }}_{{ param2 }}_{{ param3 }}_{{ param4 }}\n"
 option_2 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.variable"), 'param1': ParamValue("string"), 'param2': ParamValue(1), 'param3': ParamValue(True), 'param4': ParamValue(None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_1.rougail.variable'] = "{{ param1 }}_{{ param2 }}_{{ param3 }}_{{ param4 }}\n"
 dict_env['default_2.rougail.variable'] = "{{ param1 }}_{{ param2 }}_{{ param3 }}_{{ param4 }}\n"
 option_3 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.variable"), 'param1': ParamValue("string"), 'param2': ParamValue(1), 'param3': ParamValue(True), 'param4': ParamValue(None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.variable"), 'param1': ParamValue("string"), 'param2': ParamValue(1), 'param3': ParamValue(True), 'param4': ParamValue(None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_rougail.var'] = "{{ information }}"
 option_2 = StrOption(name="var", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.var"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_information/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.var"), 'information': ParamSelfInformation("test_information", None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation_information/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_1.rougail.var'] = "{{ information }}"
 dict_env['default_2.rougail.var'] = "{{ information }}"
 option_3 = StrOption(name="var", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.var"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_information/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.var"), 'information': ParamSelfInformation("test_information", None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="var", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.var"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_information/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.var"), 'information': ParamSelfInformation("test_information", None)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,11 +3,15 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_rougail.var2'] = "{{ information }}\n"
 option_2 = StrOption(name="var1", doc="a first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_3 = StrOption(name="var2", doc="a second variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_information_other_variable/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.var2"), 'information': ParamInformation("test_information", None, option=option_2)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation_information_other_variable/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -10,10 +14,10 @@ dict_env['default_1.rougail.var2'] = "{{ information }}\n"
 dict_env['default_2.rougail.var2'] = "{{ information }}\n"
 option_3 = StrOption(name="var1", doc="a first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_4 = StrOption(name="var2", doc="a second variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_information_other_variable/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.var2"), 'information': ParamInformation("test_information", None, option=option_3)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_7 = StrOption(name="var1", doc="a first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_8 = StrOption(name="var2", doc="a second variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_information_other_variable/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.var2"), 'information': ParamInformation("test_information", None, option=option_7)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="my_variable", doc="my_variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_2))))], default_multi=Calculation(func['calc_value'], Params((ParamOption(option_2)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation_multi_optional/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="my_variable", doc="my_variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_3))))], default_multi=Calculation(func['calc_value'], Params((ParamOption(option_3)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_7 = StrOption(name="my_variable", doc="my_variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_8 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_7))))], default_multi=Calculation(func['calc_value'], Params((ParamOption(option_7)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="my_variable", doc="my_variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_2))))], properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation_multi_optional2/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="my_variable", doc="my_variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_3))))], properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_7 = StrOption(name="my_variable", doc="my_variable", default="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_8 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_7))))], properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,9 +3,13 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation_optional/tiramisu/multi.py

@@ -3,13 +3,17 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="my_variable", doc="my_variable", multi=True, default=["val1", "val2"], default_multi="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_2)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation_optional_exists/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="my_variable", doc="my_variable", multi=True, default=["val1", "val2"], default_multi="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_4 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_3)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_7 = StrOption(name="my_variable", doc="my_variable", multi=True, default=["val1", "val2"], default_multi="val1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_8 = StrOption(name="my_calculated_variable", doc="my_calculated_variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_7)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,11 +3,15 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_rougail.var1'] = "{% if var2 is defined %} {{ var2 }} {% elif var3 is defined %} {{ var3 }} {% elif var4 is defined %} {{ var4 }} {% else %} {{ _.var2 }} {% endif %} "
 option_3 = StrOption(name="var2", doc="a second variable", default="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_2 = StrOption(name="var1", doc="a first variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.var1"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_param_optional/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.var1"), 'var2': ParamOption(option_3), '_.var2': ParamOption(option_3)})), properties=frozenset({"standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_calculation_param_optional/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -10,10 +14,10 @@ dict_env['default_1.rougail.var1'] = "{% if var2 is defined %} {{ var2 }} {% eli
 dict_env['default_2.rougail.var1'] = "{% if var2 is defined %} {{ var2 }} {% elif var3 is defined %} {{ var3 }} {% elif var4 is defined %} {{ var4 }} {% else %} {{ _.var2 }} {% endif %} "
 option_4 = StrOption(name="var2", doc="a second variable", default="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_3 = StrOption(name="var1", doc="a first variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.var1"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_param_optional/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.var1"), 'var2': ParamOption(option_4), '_.var2': ParamOption(option_4)})), properties=frozenset({"standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_8 = StrOption(name="var2", doc="a second variable", default="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_7 = StrOption(name="var1", doc="a first variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.var1"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9default_calculation_param_optional/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.var1"), 'var2': ParamOption(option_8), '_.var2': ParamOption(option_8)})), properties=frozenset({"standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"standard"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"standard"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_2 = StrOption(name="var1", doc="a first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_3 = StrOption(name="var2", doc="a second variable", default=Calculation(func['calc_value'], Params((ParamInformation("test_information", None, option=option_2)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2, option_3], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_information_other_variable/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_3 = StrOption(name="var1", doc="a first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_4 = StrOption(name="var2", doc="a second variable", default=Calculation(func['calc_value'], Params((ParamInformation("test_information", None, option=option_3)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3, option_4], properties=frozenset({"basic"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
 option_7 = StrOption(name="var1", doc="a first variable", properties=frozenset({"basic", "mandatory"}), informations={'type': 'string'})
 option_8 = StrOption(name="var2", doc="a second variable", default=Calculation(func['calc_value'], Params((ParamInformation("test_information", None, option=option_7)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_7, option_8], properties=frozenset({"basic"}))
 optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

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

@@ -3,10 +3,14 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['choices_rougail.var'] = "{% for item in trange(0, 10) %}\n{{ item }}\n{%- endfor %}\n"
 option_2 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_rougail.var"), '__internal_type': ParamValue("number"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_9default_integer/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("choices"), '__internal_variable': ParamValue("rougail.var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_9default_integer/tiramisu/multi.py

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['choices_1.rougail.var'] = "{% for item in trange(0, 10) %}\n{{ item }}\n{%- endfor %}\n"
 dict_env['choices_2.rougail.var'] = "{% for item in trange(0, 10) %}\n{{ item }}\n{%- endfor %}\n"
 option_3 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_1.rougail.var"), '__internal_type': ParamValue("number"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_9default_integer/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("choices"), '__internal_variable': ParamValue("1.rougail.var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
 option_6 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_2.rougail.var"), '__internal_type': ParamValue("number"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['tests/dictionaries/00_9default_integer/dictionaries/rougail/00-base.yml']), '__internal_attribute': ParamValue("choices"), '__internal_variable': ParamValue("2.rougail.var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
-optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_6], properties=frozenset({"standard"}))
 optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

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

@@ -3,12 +3,16 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_extra.variable'] = "no"
 option_2 = StrOption(name="variable", doc="a variable", default="rougail", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_4 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_extra.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("extra.variable")})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_3 = OptionDescription(name="extra", doc="extra", children=[option_4], properties=frozenset({"standard"}))
+optiondescription_3 = OptionDescription(name="extra", doc="extra", group_type=groups.namespace, children=[option_4], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_3])

tests/dictionaries/00_9extra/tiramisu/multi.py

@@ -3,19 +3,23 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_1.extra.variable'] = "no"
 dict_env['default_2.extra.variable'] = "no"
 option_3 = StrOption(name="variable", doc="a variable", default="rougail", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 option_5 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.extra.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.extra.variable")})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_4 = OptionDescription(name="extra", doc="extra", children=[option_5], properties=frozenset({"standard"}))
+optiondescription_4 = OptionDescription(name="extra", doc="extra", group_type=groups.namespace, children=[option_5], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2, optiondescription_4], properties=frozenset({"standard"}))
 option_8 = StrOption(name="variable", doc="a variable", default="rougail", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_7 = OptionDescription(name="rougail", doc="Rougail", children=[option_8], properties=frozenset({"standard"}))
+optiondescription_7 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_8], properties=frozenset({"standard"}))
 option_10 = StrOption(name="variable", doc="a variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.extra.variable"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.extra.variable")})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_9 = OptionDescription(name="extra", doc="extra", children=[option_10], properties=frozenset({"standard"}))
+optiondescription_9 = OptionDescription(name="extra", doc="extra", group_type=groups.namespace, children=[option_10], properties=frozenset({"standard"}))
 optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7, optiondescription_9], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6])

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

@@ -3,15 +3,19 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_extra.variable2'] = "{{ rougail.variable }}\n"
 dict_env['default_extra.variable3'] = "{{ variable }}\n"
 option_2 = StrOption(name="variable", doc="a variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_2], properties=frozenset({"standard"}))
 option_4 = StrOption(name="variable1", doc="a first variable", default=Calculation(func['calc_value'], Params((ParamOption(option_2)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_5 = StrOption(name="variable2", doc="a second variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_extra.variable2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra_calculation/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("extra.variable2"), 'rougail.variable': ParamOption(option_2)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_6 = StrOption(name="variable3", doc="a third variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_extra.variable3"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra_calculation/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("extra.variable3"), 'variable': ParamOption(option_2)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_3 = OptionDescription(name="extra", doc="extra", children=[option_4, option_5, option_6], properties=frozenset({"standard"}))
+optiondescription_3 = OptionDescription(name="extra", doc="extra", group_type=groups.namespace, children=[option_4, option_5, option_6], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_3])

tests/dictionaries/00_9extra_calculation/tiramisu/multi.py

@@ -3,6 +3,10 @@ from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
 from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
+try:
+    groups.namespace
+except:
+    groups.addgroup('namespace')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
@@ -11,17 +15,17 @@ dict_env['default_1.extra.variable3'] = "{{ variable }}\n"
 dict_env['default_2.extra.variable2'] = "{{ rougail.variable }}\n"
 dict_env['default_2.extra.variable3'] = "{{ variable }}\n"
 option_3 = StrOption(name="variable", doc="a variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_3], properties=frozenset({"standard"}))
 option_5 = StrOption(name="variable1", doc="a first variable", default=Calculation(func['calc_value'], Params((ParamOption(option_3)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_6 = StrOption(name="variable2", doc="a second variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.extra.variable2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra_calculation/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.extra.variable2"), 'rougail.variable': ParamOption(option_3)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_7 = StrOption(name="variable3", doc="a third variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.extra.variable3"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra_calculation/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.extra.variable3"), 'variable': ParamOption(option_3)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_4 = OptionDescription(name="extra", doc="extra", children=[option_5, option_6, option_7], properties=frozenset({"standard"}))
+optiondescription_4 = OptionDescription(name="extra", doc="extra", group_type=groups.namespace, children=[option_5, option_6, option_7], properties=frozenset({"standard"}))
 optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2, optiondescription_4], properties=frozenset({"standard"}))
 option_10 = StrOption(name="variable", doc="a variable", default="value", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_9 = OptionDescription(name="rougail", doc="Rougail", children=[option_10], properties=frozenset({"standard"}))
+optiondescription_9 = OptionDescription(name="rougail", doc="Rougail", group_type=groups.namespace, children=[option_10], properties=frozenset({"standard"}))
 option_12 = StrOption(name="variable1", doc="a first variable", default=Calculation(func['calc_value'], Params((ParamOption(option_10)))), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_13 = StrOption(name="variable2", doc="a second variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.extra.variable2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra_calculation/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.extra.variable2"), 'rougail.variable': ParamOption(option_10)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_14 = StrOption(name="variable3", doc="a third variable", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.extra.variable3"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['tests/dictionaries/00_9extra_calculation/dictionaries/extra/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.extra.variable3"), 'variable': ParamOption(option_10)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-optiondescription_11 = OptionDescription(name="extra", doc="extra", children=[option_12, option_13, option_14], properties=frozenset({"standard"}))
+optiondescription_11 = OptionDescription(name="extra", doc="extra", group_type=groups.namespace, children=[option_12, option_13, option_14], properties=frozenset({"standard"}))
 optiondescription_8 = OptionDescription(name="2", doc="2", children=[optiondescription_9, optiondescription_11], properties=frozenset({"standard"}))
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_8])