bump: version 1.2.0a3 → 1.2.0a4

CHANGELOG.md

@@ -1,3 +1,48 @@
+## 1.2.0a4 (2024-12-11)
+
+### Feat
+
+- move test to a new project rougail-tests
+- output could have annotator
+
+### Fix
+
+- remove link
+- reorganise user_datas
+- only change prefix if path is relative
+
+## 1.2.0a3 (2024-11-28)
+
+### Fix
+
+- add user_datas file
+
+## 1.2.0a2 (2024-11-27)
+
+### Feat
+
+- add "exists" attribut for a family
+
+### Fix
+
+- separate UserDatas
+- options could be a list
+
+## 1.2.0a1 (2024-11-25)
+
+### Fix
+
+- dynamic variable could be optional
+- dynamic variable declare in verion 1.0 has {{ suffix }}
+- user_data plugins could have annotator function
+- do not modify a dynamic variable if has default value
+
+## 1.2.0a0 (2024-11-08)
+
+### Feat
+
+- add force_optional option to allow charging structure even if all variables are not available
+
 ## 1.1.1 (2024-11-06)
 
 ### Fix

locale/fr/LC_MESSAGES/rougail.po

@@ -5,8 +5,8 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: \n"
-"POT-Creation-Date: 2024-10-30 13:21+0100\n"
-"PO-Revision-Date: 2024-10-30 13:39+0100\n"
+"POT-Creation-Date: 2024-11-25 09:10+0100\n"
+"PO-Revision-Date: 2024-11-25 09:11+0100\n"
 "Last-Translator: \n"
 "Language-Team: \n"
 "Language: fr\n"
@@ -16,31 +16,31 @@ msgstr ""
 "Generated-By: pygettext.py 1.5\n"
 "X-Generator: Poedit 3.5\n"
 
-#: src/rougail/annotator/family.py:142
+#: src/rougail/annotator/family.py:141
 msgid "default variable mode \"{0}\" is not a valid mode, valid modes are {1}"
 msgstr ""
 "le mode d'une variable par défaut \"{0}\" n'est pas un mode valide, les "
 "modes valides sont {1}"
 
-#: src/rougail/annotator/family.py:148
+#: src/rougail/annotator/family.py:147
 msgid "default family mode \"{0}\" is not a valid mode, valid modes are {1}"
 msgstr ""
 "le mode d'une famille par défaut \"{0}\" n'est pas un mode valide, les modes "
 "valides sont {1}"
 
-#: src/rougail/annotator/family.py:180
+#: src/rougail/annotator/family.py:179
 msgid "mode \"{0}\" for \"{1}\" is not a valid mode, valid modes are {2}"
 msgstr ""
 "le mode \"{0}\" pour \"{1}\" n'est pas un mode valide, les modes valides "
 "sont {2}"
 
-#: src/rougail/annotator/family.py:184
+#: src/rougail/annotator/family.py:183
 msgid "mode \"{0}\" for \"{1}\" is not a valid mode, no modes are available"
 msgstr ""
 "le mode \"{0}\" pour \"{1}\" n'est pas un mode valide, aucun mode ne sont "
 "définis"
 
-#: src/rougail/annotator/family.py:248
+#: src/rougail/annotator/family.py:247
 msgid ""
 "the variable \"{0}\" is mandatory so in \"{1}\" mode but family has the "
 "higher family mode \"{2}\""
@@ -48,7 +48,7 @@ msgstr ""
 "la variable \"{0}\" est obligatoire donc dans le mode \"{1}\" mais la "
 "famille a un mode supérieur \"{2}\""
 
-#: src/rougail/annotator/family.py:286
+#: src/rougail/annotator/family.py:285
 msgid ""
 "the follower \"{0}\" is in \"{1}\" mode but leader have the higher mode "
 "\"{2}\""
@@ -56,7 +56,7 @@ msgstr ""
 "la variable suiveuse \"{0}\" a le mode \"{1}\" mais la variable leader a un "
 "mode supérieur \"{2}\""
 
-#: src/rougail/annotator/family.py:319
+#: src/rougail/annotator/family.py:318
 msgid ""
 "the family \"{0}\" is in \"{1}\" mode but variables and families inside have "
 "the higher modes \"{2}\""
@@ -64,7 +64,7 @@ msgstr ""
 "la famille \"{0}\" a le mode \"{1}\" mais les variables et les familles à "
 "l'intérieur ont des modes supérieurs \"{2}\""
 
-#: src/rougail/annotator/family.py:337
+#: src/rougail/annotator/family.py:336
 msgid ""
 "the variable \"{0}\" is in \"{1}\" mode but family has the higher family "
 "mode \"{2}\""
@@ -72,37 +72,37 @@ msgstr ""
 "la variable \"{0}\" est dans le mode \"{1}\" mais la famille a le mode "
 "supérieur \"{2}\""
 
-#: src/rougail/annotator/value.py:80
+#: src/rougail/annotator/value.py:77
 msgid "the follower \"{0}\" without multi attribute can only have one value"
 msgstr ""
 "la variable suiveuse \"{0}\" sans l'attribut multi peut avoir seulement une "
 "valeur"
 
-#: src/rougail/annotator/value.py:96
+#: src/rougail/annotator/value.py:93
 msgid "the variable \"{0}\" is multi but has a non list default value"
 msgstr ""
 "la variable \"{0}\" est multiple mais a une valeur par défaut sans être une "
 "liste"
 
-#: src/rougail/annotator/variable.py:192
+#: src/rougail/annotator/variable.py:189
 msgid ""
 "the variable \"{0}\" has regexp attribut but has not the \"regexp\" type"
 msgstr ""
 "la variable \"{0}\" a un attribut regexp mais n'a pas le type \"regexp\""
 
-#: src/rougail/annotator/variable.py:235
+#: src/rougail/annotator/variable.py:232
 msgid ""
 "the variable \"{0}\" has choices attribut but has not the \"choice\" type"
 msgstr ""
 "la variable \"{0}\" a un attribut choices mais n'a pas le type \"choice\""
 
-#: src/rougail/annotator/variable.py:263
+#: src/rougail/annotator/variable.py:260
 msgid ""
 "the variable \"{0}\" has an unvalid default value \"{1}\" should be in {2}"
 msgstr ""
 "la variable \"{0}\" a la valeur par défaut invalide \"{1}\" devrait être {2}"
 
-#: src/rougail/convert.py:268
+#: src/rougail/convert.py:281
 msgid ""
 "A variable or a family located in the \"{0}\" namespace shall not be used in "
 "the \"{1}\" namespace"
@@ -110,38 +110,38 @@ msgstr ""
 "Une variable ou une famille localisé dans l'espace de nom \"{0}\" ne devrait "
 "pas être utilisé dans l'espace de nom \"{1}\""
 
-#: src/rougail/convert.py:462
+#: src/rougail/convert.py:477
 msgid "unknown type {0} for {1}"
 msgstr "type {0} inconnu pour {1}"
 
-#: src/rougail/convert.py:1323
+#: src/rougail/convert.py:1347
 msgid "duplicate dictionary file name {0}"
 msgstr "nom de fichier {0} de dictionnaire dupliqué"
 
-#: src/rougail/convert.py:1370
+#: src/rougail/convert.py:1394
 msgid "Cannot execute annotate multiple time"
 msgstr "Ne peut exécuter l'annotation plusieurs fois"
 
-#: src/rougail/error.py:70
+#: src/rougail/error.py:67
 msgid "{0} in {1}"
 msgstr "{0} dans {1}"
 
-#: src/rougail/structural_commandline/annotator.py:70
+#: src/rougail/structural_commandline/annotator.py:67
 msgid "alternative_name \"{0}\" conflict with \"--help\""
 msgstr "alternative_name \"{0}\" est en conflit avec \"--help\""
 
-#: src/rougail/structural_commandline/annotator.py:73
+#: src/rougail/structural_commandline/annotator.py:72
 msgid "conflict alternative_name \"{0}\": \"{1}\" and \"{2}\""
 msgstr "conflit dans les \"alternative_name\" \"{0}\": \"{1}\" et \"{2}\""
 
-#: src/rougail/structural_commandline/annotator.py:96
+#: src/rougail/structural_commandline/annotator.py:95
 msgid ""
 "negative_description is mandatory for boolean variable, but \"{0}\" hasn't"
 msgstr ""
 "l'attribut negative_description est obligatoire pour des variables "
 "\"boolean\", mais \"{0}\" n'en a pas"
 
-#: src/rougail/structural_commandline/annotator.py:105
+#: src/rougail/structural_commandline/annotator.py:104
 msgid ""
 "negative_description is only available for boolean variable, but \"{0}\" is "
 "\"{1}\""
@@ -149,11 +149,11 @@ msgstr ""
 "l'attribut negative_description est seulement valide pour des variables "
 "\"boolean\", mais \"{0}\" est \"{1}\""
 
-#: src/rougail/update/update.py:741
+#: src/rougail/update/update.py:738
 msgid "not a XML file: {0}"
 msgstr "fichier XML invalid : {0}"
 
-#: src/rougail/utils.py:58
+#: src/rougail/utils.py:55
 msgid ""
 "invalid variable or family name \"{0}\" must only contains lowercase ascii "
 "character, number or _"
@@ -161,6 +161,6 @@ msgstr ""
 "nom invalide pour la variable ou famille \"{0}\" doit seulement contenir des "
 "caractères ascii minuscule, nombre or _"
 
-#: src/rougail/utils.py:120
+#: src/rougail/utils.py:117
 msgid "error in jinja \"{0}\" for the variable \"{1}\": {2}"
 msgstr "erreur dans Jinja \"{0}\" pour la variable \"{1}\": {2}"

locale/rougail.pot

@@ -5,7 +5,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
-"POT-Creation-Date: 2024-11-04 12:04+0100\n"
+"POT-Creation-Date: 2024-11-25 09:10+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -15,35 +15,35 @@ msgstr ""
 "Generated-By: pygettext.py 1.5\n"
 
 
-#: src/rougail/annotator/family.py:139
+#: src/rougail/annotator/family.py:141
 msgid "default variable mode \"{0}\" is not a valid mode, valid modes are {1}"
 msgstr ""
 
-#: src/rougail/annotator/family.py:145
+#: src/rougail/annotator/family.py:147
 msgid "default family mode \"{0}\" is not a valid mode, valid modes are {1}"
 msgstr ""
 
-#: src/rougail/annotator/family.py:177
+#: src/rougail/annotator/family.py:179
 msgid "mode \"{0}\" for \"{1}\" is not a valid mode, valid modes are {2}"
 msgstr ""
 
-#: src/rougail/annotator/family.py:181
+#: src/rougail/annotator/family.py:183
 msgid "mode \"{0}\" for \"{1}\" is not a valid mode, no modes are available"
 msgstr ""
 
-#: src/rougail/annotator/family.py:245
+#: src/rougail/annotator/family.py:247
 msgid "the variable \"{0}\" is mandatory so in \"{1}\" mode but family has the higher family mode \"{2}\""
 msgstr ""
 
-#: src/rougail/annotator/family.py:283
+#: src/rougail/annotator/family.py:285
 msgid "the follower \"{0}\" is in \"{1}\" mode but leader have the higher mode \"{2}\""
 msgstr ""
 
-#: src/rougail/annotator/family.py:316
+#: src/rougail/annotator/family.py:318
 msgid "the family \"{0}\" is in \"{1}\" mode but variables and families inside have the higher modes \"{2}\""
 msgstr ""
 
-#: src/rougail/annotator/family.py:334
+#: src/rougail/annotator/family.py:336
 msgid "the variable \"{0}\" is in \"{1}\" mode but family has the higher family mode \"{2}\""
 msgstr ""
 
@@ -71,15 +71,15 @@ msgstr ""
 msgid "A variable or a family located in the \"{0}\" namespace shall not be used in the \"{1}\" namespace"
 msgstr ""
 
-#: src/rougail/convert.py:475
+#: src/rougail/convert.py:477
 msgid "unknown type {0} for {1}"
 msgstr ""
 
-#: src/rougail/convert.py:1345
+#: src/rougail/convert.py:1347
 msgid "duplicate dictionary file name {0}"
 msgstr ""
 
-#: src/rougail/convert.py:1392
+#: src/rougail/convert.py:1394
 msgid "Cannot execute annotate multiple time"
 msgstr ""
 

pyproject.toml

@@ -4,7 +4,7 @@ requires = ["flit_core >=3.8.0,<4"]
 
 [project]
 name = "rougail"
-version = "1.1.1"
+version = "1.2.0a4"
 authors = [{name = "Emmanuel Garette", email = "gnunux@gnunux.info"}]
 readme = "README.md"
 description = "A consistency handling system that was initially designed in the configuration management"

src/rougail/__init__.py

@@ -25,17 +25,15 @@ You should have received a copy of the GNU Lesser General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-from tiramisu import Config, undefined
-from tiramisu.error import PropertiesOptionError, LeadershipError, ConfigError
+from tiramisu import Config
 from warnings import warn
-from typing import List
-from re import compile, findall
 
 from .convert import RougailConvert
 from .config import RougailConfig
 from .update import RougailUpgrade
-from .object_model import CONVERT_OPTION
 from .utils import normalize_family
+from .object_model import CONVERT_OPTION
+from .user_datas import UserDatas
 
 
 def tiramisu_display_name(
@@ -58,7 +56,7 @@ def tiramisu_display_name(
     return f"{path}{comment}"
 
 
-class Rougail:
+class Rougail(UserDatas):
     """Main Rougail object"""
 
     def __init__(
@@ -104,223 +102,5 @@ class Rougail:
         )
         return self.run()
 
-    def user_datas(self, user_datas: List[dict]):
-        values = {}
-        errors = []
-        warnings = []
-        for datas in user_datas:
-            options = datas.get("options", {})
-            for name, data in datas.get("values", {}).items():
-                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._get_variable(self.config):
-                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(value)
-                    value_is_set = True
-                    if index is not None:
-                        values[path]["values"][index] = undefined
-                        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():
-            try:
-                option = self.config.option(path)
-                value = data["values"]
-                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, LeadershipError) as err:
-                # 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(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/__init__.py

@@ -71,6 +71,16 @@ class SpaceAnnotator:  # pylint: disable=R0903
             if extra_annotator in ANNOTATORS:
                 continue
             get_annotators(ANNOTATORS, extra_annotator)
+        if objectspace.output:
+            try:
+                get_annotators(ANNOTATORS, f"rougail.output_{objectspace.output}", "annotator")
+            except ModuleNotFoundError:
+                pass
+        for user_data in objectspace.user_datas:
+            try:
+                get_annotators(ANNOTATORS, f"rougail.user_data_{user_data}", "annotator")
+            except ModuleNotFoundError:
+                pass
         for plugin in objectspace.plugins:
             try:
                 get_annotators(ANNOTATORS, f"rougail.{plugin}", "annotator")
@@ -81,6 +91,10 @@ class SpaceAnnotator:  # pylint: disable=R0903
             annotators.extend(ANNOTATORS[extra_annotator])
         for plugin in objectspace.plugins:
             annotators.extend(ANNOTATORS[f"rougail.{plugin}.annotator"])
+        for user_data in objectspace.user_datas:
+            annotators.extend(ANNOTATORS[f"rougail.user_data_{user_data}.annotator"])
+        if objectspace.output:
+            annotators.extend(ANNOTATORS[f"rougail.output_{objectspace.output}.annotator"])
         annotators = sorted(annotators, key=get_level)
         functions = {}
         functions_files = objectspace.functions_files

src/rougail/annotator/family.py

@@ -125,10 +125,14 @@ class Annotator(Walk):
             if family.type == "dynamic" and isinstance(
                 family.dynamic, VariableCalculation
             ):
-                path = self.objectspace.paths.get_full_path(
-                    family.dynamic.variable,
-                    family.path,
-                )
+                path = family.dynamic.variable
+                if family.version != "1.0" and self.objectspace.paths.regexp_relative.search(path):
+                    path = self.objectspace.paths.get_full_path(
+                        family.dynamic.variable,
+                        family.path,
+                    )
+                if family.version == '1.0' and "{{ suffix }}" in path:
+                    path = path.replace("{{ suffix }}", "{{ identifier }}")
                 self.objectspace.informations.add(family.path, "dynamic_variable", path)
 
     def change_modes(self):

src/rougail/annotator/property.py

@@ -120,7 +120,7 @@ class Annotator(Walk):
             else:
                 value = []
                 for calculation in frozen:
-                    calculation_copy = calculation.copy()
+                    calculation_copy = calculation.model_copy()
                     calculation_copy.attribute_name = "frozen"
                     calculation_copy.ori_path = calculation_copy.path
                     calculation_copy.path = path

src/rougail/annotator/value.py

@@ -92,7 +92,7 @@ class Annotator(Walk):  # pylint: disable=R0903
         elif variable.multi:
             msg = _(
                 'the variable "{0}" is multi but has a non list default value'
-            ).format(variable.name)
+            ).format(variable.path)
             raise DictConsistencyError(msg, 12, variable.xmlfiles)
         elif variable.path in self.objectspace.followers:
             self.objectspace.default_multi[variable.path] = variable.default

src/rougail/config.py

@@ -26,12 +26,16 @@ You should have received a copy of the GNU Lesser General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
 
+from sys import version_info
+
 from pathlib import Path
 from tiramisu import Config
 from ruamel.yaml import YAML
 from .utils import _, load_modules, normalize_family
 from .convert import RougailConvert
 
+if version_info.major == 3 and version_info.minor:
+    import rougail.structural_commandline.object_model
 
 RENAMED = {
     "dictionaries_dir": "main_dictionaries",
@@ -182,7 +186,10 @@ class FakeRougailConvert(RougailConvert):
         self.base_option_name = "baseoption"
         self.export_with_import = True
         self.internal_functions = []
+        self.force_optional = False
         self.plugins = ["structural_commandline"]
+        self.user_datas = []
+        self.output = None
         self.add_extra_options = self.add_extra_options
 
 
@@ -387,6 +394,11 @@ suffix:
   default: ''
   mandatory: false
   commandline: false
+
+force_optional:
+  description: Every variable in calculation are optional
+  negative_description: Variable in calculation are not optional by default
+  default: False
 """
     processes = {
         "structural": [],
@@ -477,12 +489,17 @@ suffix:
                 extra_vars |= obj["extra_vars"]
             if not "options" in obj:
                 continue
-            convert.parse_root_file(
-                f'rougail.config.{obj["name"]}',
-                "",
-                "1.1",
-                YAML().load(obj["options"]),
-            )
+            if not isinstance(obj["options"], list):
+                options = [obj["options"]]
+            else:
+                options = obj["options"]
+            for option in options:
+                convert.parse_root_file(
+                    f'rougail.config.{obj["name"]}',
+                    "",
+                    "1.1",
+                    YAML().load(option),
+                )
 
     tiram_obj = convert.save(None)
     optiondescription = {}

src/rougail/convert.py

@@ -390,9 +390,12 @@ class ParserVariable:
         self.base_option_name = rougailconfig["base_option_name"]
         self.export_with_import = rougailconfig["export_with_import"]
         self.internal_functions = rougailconfig["internal_functions"]
+        self.force_optional = rougailconfig["force_optional"]
         self.add_extra_options = rougailconfig[
             "structural_commandline.add_extra_options"
         ]
+        self.user_datas = rougailconfig["step.user_data"]
+        self.output = rougailconfig["step.output"]
         self.plugins = rougailconfig["plugins"]
 
     def _init(self):
@@ -426,7 +429,7 @@ class ParserVariable:
         # FIXME: only for format 1.0
         self.family_types = hint["type"].__args__  # pylint: disable=W0201
         self.family_attrs = frozenset(  # pylint: disable=W0201
-            set(hint) - {"name", "path", "xmlfiles"} | {"redefine"}
+            set(hint) - {"name", "path", "xmlfiles"} | {"redefine", "exists"}
         )
         self.family_calculations = self.search_calculation(  # pylint: disable=W0201
             hint
@@ -588,6 +591,10 @@ class ParserVariable:
             return
         family_obj = {}
         subfamily_obj = {}
+        if version != '1.0':
+            exists = obj.pop("exists", None)
+        else:
+            exists = None
         force_to_attrs = list(self.list_attributes(obj))
         for key, value in obj.items():
             if key in force_to_attrs:
@@ -599,9 +606,9 @@ class ParserVariable:
         if path in self.paths:
             # it's just for modify subfamily or subvariable, do not redefine
             if family_obj:
-                if not obj.pop("redefine", False):
+                if exists in [None, True] and not obj.pop("redefine", False):
                     raise DictConsistencyError(
-                        f'The family "{path}" already exists and it is not redefined',
+                        _('The family "{0}" already exists and it is not redefined').format(path),
                         32,
                         [filename],
                     )
@@ -615,20 +622,21 @@ class ParserVariable:
                     version,
                     typ="family",
                 )
-                self.paths.add(
-                    path,
-                    self.paths[path].model_copy(update=obj),
-                    family_is_dynamic,
-                    parent_dynamic,
-                    force=True,
-                )
+                if exists in [None, True]:
+                    self.paths.add(
+                        path,
+                        self.paths[path].model_copy(update=obj),
+                        family_is_dynamic,
+                        parent_dynamic,
+                        force=True,
+                    )
             self.paths[path].xmlfiles.append(filename)
             force_not_first = True
             if self.paths[path].type == "dynamic":
                 family_is_dynamic = True
                 parent_dynamic = path
         else:
-            if "redefine" in obj and obj["redefine"]:
+            if exists is None and "redefine" in obj and obj["redefine"]:
                 raise Exception(
                     f'cannot redefine the inexisting family "{path}" in {filename}'
                 )

src/rougail/error.py

@@ -81,6 +81,10 @@ class NotFoundError(Exception):
     pass
 
 
+class ExtentionError(Exception):
+    pass
+
+
 ## ---- specific exceptions ----
 
 

src/rougail/object_model.py

@@ -332,6 +332,7 @@ class JinjaCalculation(Calculation):
                 }
                 if self.version != "1.0":
                     default["params"][true_path]["propertyerror"] = False
+                    default["params"][true_path]["optional"] = True
                 if identifier:
                     default["params"][true_path]["identifier"] = identifier
         return default
@@ -432,13 +433,17 @@ class _VariableCalculation(Calculation):
         needs_multi: Optional[bool] = None,
     ):
         if not variable:
-            msg = f'Variable not found "{self.variable}" for attribut "{self.attribute_name}" for variable "{self.path}"'
-            raise DictConsistencyError(msg, 88, self.xmlfiles)
+            if not objectspace.force_optional:
+                msg = f'Variable not found "{self.variable}" for attribut "{self.attribute_name}" for variable "{self.path}"'
+                raise DictConsistencyError(msg, 88, self.xmlfiles)
+            return {None: [['example']]}
         param = {
             "type": "variable",
             "variable": variable,
             "propertyerror": self.propertyerror,
         }
+        if isinstance(self, VariableCalculation) and self.optional:
+            param["optional"] = self.optional
         if identifier:
             param["identifier"] = identifier
         params = {None: [param]}
@@ -488,6 +493,12 @@ class _VariableCalculation(Calculation):
                 raise DictConsistencyError(msg, 21, self.xmlfiles)
             else:
                 params[None][0]["index"] = {"index": {"type": "index"}}
+        if self.path in objectspace.followers:
+            multi = objectspace.multis[self.path] == "submulti"
+        else:
+            multi = self.path in objectspace.multis
+        if multi:
+            params["__internal_multi"] = True
         return params
 
 
@@ -503,7 +514,7 @@ class VariableCalculation(_VariableCalculation):
             msg = f'"{self.attribute_name}" variable shall not have an "optional" attribute for variable "{self.variable}"'
             raise DictConsistencyError(msg, 33, self.xmlfiles)
         variable, identifier = self.get_variable(objectspace)
-        if not variable and self.optional:
+        if not variable and self.optional or (objectspace.force_optional and self.attribute_name == "default"):
             raise VariableCalculationDependencyError()
         params = self.get_params(
             objectspace,
@@ -517,7 +528,8 @@ class VariableCalculation(_VariableCalculation):
 
 
 class VariablePropertyCalculation(_VariableCalculation):
-    attribute_name: Literal[*PROPERTY_ATTRIBUTE]
+    # For python 3.9 attribute_name: Literal[*PROPERTY_ATTRIBUTE]
+    attribute_name: Literal["frozen", "hidden", "disabled", "mandatory"]
     when: Any = undefined
     when_not: Any = undefined
 
@@ -532,30 +544,31 @@ class VariablePropertyCalculation(_VariableCalculation):
             identifier,
             needs_multi=False,
         )
-        variable = params[None][0]["variable"]
-        if self.when is not undefined:
-            if self.version == "1.0":
-                msg = f'when is not allowed in format version 1.0 for attribute "{self.attribute_name}" for variable "{self.path}"'
-                raise DictConsistencyError(msg, 103, variable.xmlfiles)
-            if self.when_not is not undefined:
-                msg = f'the variable "{self.path}" has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
-                raise DictConsistencyError(msg, 31, variable.xmlfiles)
-            when = self.when
-            inverse = False
-        elif self.when_not is not undefined:
-            if self.version == "1.0":
-                msg = f'when_not is not allowed in format version 1.0 for attribute "{self.attribute_name}" for variable "{self.path}"'
-                raise DictConsistencyError(msg, 104, variable.xmlfiles)
-            when = self.when_not
-            inverse = True
-        else:
-            if variable.type != "boolean":
-                raise Exception("only boolean!")
-            when = True
-            inverse = False
+        if params[None] and "variable" in params[None][0]:
+            variable = params[None][0]["variable"]
+            if self.when is not undefined:
+                if self.version == "1.0":
+                    msg = f'when is not allowed in format version 1.0 for attribute "{self.attribute_name}" for variable "{self.path}"'
+                    raise DictConsistencyError(msg, 103, variable.xmlfiles)
+                if self.when_not is not undefined:
+                    msg = f'the variable "{self.path}" has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
+                    raise DictConsistencyError(msg, 31, variable.xmlfiles)
+                when = self.when
+                inverse = False
+            elif self.when_not is not undefined:
+                if self.version == "1.0":
+                    msg = f'when_not is not allowed in format version 1.0 for attribute "{self.attribute_name}" for variable "{self.path}"'
+                    raise DictConsistencyError(msg, 104, variable.xmlfiles)
+                when = self.when_not
+                inverse = True
+            else:
+                if variable.type != "boolean":
+                    raise Exception("only boolean!")
+                when = True
+                inverse = False
+            params["when"] = when
+            params["inverse"] = inverse
         params[None].insert(0, self.attribute_name)
-        params["when"] = when
-        params["inverse"] = inverse
         return {
             "function": "variable_to_property",
             "params": params,
@@ -593,9 +606,15 @@ class InformationCalculation(Calculation):
                 self.namespace,
                 self.xmlfiles,
             )
-            if variable is None or identifier is not None:
-                raise Exception("pfff")
-            params[None][0]["variable"] = variable
+            if variable is None:
+                if not objectspace.force_optional:
+                    msg = f'cannot find variable "{self.variable}" for the information "{self.information}" when calculating "{self.attribute_name}"'
+                    raise DictConsistencyError(msg, 40, variable.xmlfiles)
+            if identifier is not None:
+                msg = f'identifier not allowed for the information "{self.information}" when calculating "{self.attribute_name}"'
+                raise DictConsistencyError(msg, 41, variable.xmlfiles)
+            if variable:
+                params[None][0]["variable"] = variable
         if self.default_values:
             params["__default_value"] = self.default_values
         return {
@@ -631,7 +650,8 @@ class IdentifierCalculation(_IdentifierCalculation):
 
 
 class IdentifierPropertyCalculation(_IdentifierCalculation):
-    attribute_name: Literal[*PROPERTY_ATTRIBUTE]
+    # for python 3.9 attribute_name: Literal[*PROPERTY_ATTRIBUTE]
+    attribute_name: Literal["frozen", "hidden", "disabled", "mandatory"]
     when: Any = undefined
     when_not: Any = undefined
 

src/rougail/tiramisu.py

@@ -27,10 +27,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from typing import Any
 
-try:
-    from tiramisu5 import DynOptionDescription, calc_value
-except ModuleNotFoundError:
-    from tiramisu import DynOptionDescription, calc_value
 from importlib.machinery import SourceFileLoader as _SourceFileLoader
 from importlib.util import (
     spec_from_loader as _spec_from_loader,
@@ -40,8 +36,8 @@ from jinja2 import StrictUndefined, DictLoader
 from jinja2.sandbox import SandboxedEnvironment
 from rougail.object_model import CONVERT_OPTION
 from rougail.error import display_xmlfiles
-from tiramisu import function_waiting_for_error
-from tiramisu.error import ValueWarning, ConfigError, PropertiesOptionError
+from tiramisu import DynOptionDescription, calc_value, function_waiting_for_error
+from tiramisu.error import ValueWarning, ConfigError, PropertiesOptionError, CancelParam
 from .utils import normalize_family
 
 
@@ -102,8 +98,10 @@ def load_functions(path):
         func[function] = getattr(func_, function)
 
 
-def rougail_calc_value(*args, __default_value=None, **kwargs):
+def rougail_calc_value(*args, __default_value=None, __internal_multi=False, **kwargs):
     values = calc_value(*args, **kwargs)
+    if values is None and __internal_multi:
+        values = []
     if __default_value is not None and values in [None, []]:
         return __default_value
     return values
@@ -128,9 +126,13 @@ def jinja_to_function(
         if "." in key:
             c_kw = kw
             path, var = key.rsplit(".", 1)
+            if isinstance(value, CancelParam):
+                count_o_path = value.origin_path.count('.') - value.current_path.count('.')
+                path = path.rsplit(".", count_o_path)[0]
             for subkey in path.split("."):
                 c_kw = c_kw.setdefault(subkey, {})
-            c_kw[var] = value
+            if not isinstance(value, CancelParam):
+                c_kw[var] = value
         else:
             if key in kw:
                 raise ConfigError(

src/rougail/tiramisureflector.py

@@ -339,6 +339,7 @@ class Common:
             return self.build_option_param(
                 param["variable"],
                 param.get("propertyerror", True),
+                param.get("optional", False),
                 param.get("identifier"),
                 param.get("dynamic"),
                 param.get("whole", False),
@@ -355,6 +356,7 @@ class Common:
         self,
         variable,
         propertyerror,
+        optional: bool,
         identifier: Optional[str],
         dynamic,
         whole: bool,
@@ -377,6 +379,8 @@ class Common:
                     ident = self.convert_str(ident)
                 identifiers.append(str(ident))
             params.append("[" + ", ".join(identifiers) + "]")
+            if optional:
+                params.append("optional=True")
         else:
             param_type = "ParamOption"
         if not propertyerror:

src/rougail/user_datas.py

@@ -0,0 +1,243 @@
+"""
+Silique (https://www.silique.fr)
+Copyright (C) 2024
+
+distribued with GPL-2 or later license
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+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 typing import List
+from re import findall
+
+from tiramisu import undefined, Calculation
+from tiramisu.error import PropertiesOptionError, LeadershipError, ConfigError
+
+from .object_model import CONVERT_OPTION
+
+
+class UserDatas:
+    def __init__(self, config) -> None:
+        self.config = config
+
+    def user_datas(self, user_datas: List[dict]):
+        self.values = {}
+        self.errors = []
+        self.warnings = []
+        self._populate_values(user_datas)
+        self._auto_configure_dynamics()
+        self._populate_config()
+        self._populate_error_warnings()
+        return {
+            "errors": self.errors,
+            "warnings": self.warnings,
+        }
+
+    def _populate_values(self, user_datas):
+        for datas in user_datas:
+            options = datas.get("options", {})
+            for name, data in datas.get("values", {}).items():
+                self.values[name] = {
+                    "values": data,
+                    "options": options.copy(),
+                }
+            self.errors.extend(datas.get("errors", []))
+            self.warnings.extend(datas.get("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):
+        cache = {}
+        added = []
+        for path, data in list(self.values.items()):
+            value = data["values"]
+            try:
+                option = self.config.option(path)
+                option.name()
+            except (ConfigError, PropertiesOptionError):
+                pass
+            except AttributeError:
+                self._not_found_is_dynamic(self.config, path, cache, added)
+
+    def _not_found_is_dynamic(self, config, path, cache, added):
+        """if path is not found, check if parent is a dynamic family
+        """
+        current_path = ""
+        identifiers = []
+        # get parent
+        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)
+                continue
+            tconfig = config.option(name)
+            try:
+                tconfig.group_type()
+                # object exists, so current config is the temporary config
+                config = tconfig
+                if config.isdynamic(only_self=True):
+                    identifiers.append(config.identifiers()[-1])
+            except AttributeError:
+                # try to found the good dynamic family
+                for tconfig in config.list(uncalculated=True):
+                    if not tconfig.isdynamic(only_self=True):
+                        # it's not a dynamic variable
+                        continue
+                    identifier = self._get_identifier(
+                        tconfig.name(), name
+                    )
+                    if identifier is None:
+                        # it's a dynamic variable but doesn't match the current name
+                        continue
+                    dynamic_variable = tconfig.information.get(
+                        "dynamic_variable",
+                        None,
+                    )
+                    if not dynamic_variable:
+                        # it's the good dynamic variable but it's not linked to a variable
+                        # so cannot change the variable
+                        continue
+                    option_type = self.config.option(
+                        dynamic_variable
+                    ).information.get("type")
+                    dyn_options_values = self.config.option(dynamic_variable).get().impl_getdefault()
+                    if "{{ identifier }}" in  dynamic_variable:
+                        for s in identifiers:
+                            dynamic_variable = dynamic_variable.replace(
+                                "{{ identifier }}", str(s), 1
+                            )
+                    if dynamic_variable not in self.values and not dyn_options_values:
+                        self.values[dynamic_variable] = {"values": []}
+                        added.append(dynamic_variable)
+                    elif dynamic_variable not in added:
+                        continue
+                    config = tconfig
+                    identifiers.append(identifier)
+                    typ = CONVERT_OPTION.get(option_type, {}).get(
+                        "func"
+                    )
+                    if typ:
+                        identifier = typ(identifier)
+                    if (
+                        identifier
+                        not in self.values[dynamic_variable]["values"]
+                    ):
+                        self.values[dynamic_variable]["values"].append(
+                            identifier
+                        )
+                    cache[current_path] = config, identifier
+                    break
+
+    def _populate_config(self):
+        while self.values:
+            value_is_set = False
+            for option in self._get_variable(self.config):
+                path = option.path()
+                if path not in self.values:
+                    continue
+                options = self.values[path].get("options", {})
+                value = self.values[path]["values"]
+                needs_convert = options.get("needs_convert", False)
+
+                # converted value
+                if option.ismulti():
+                    if options.get("multi_separator") and not isinstance(value, list):
+                        value = value.split(options["multi_separator"])
+                        self.values[path]["values"] = value
+                        if option.issubmulti():
+                            value = [[val] for val in value]
+                    if needs_convert:
+                        if option.issubmulti():
+                            for idx, val in enumerate(value):
+                                value[idx] = [convert_value(option, v) for v in val]
+                        else:
+                            value = [convert_value(option, val) for val in value]
+                        self.values[path]["values"] = value
+                        self.values[path]["options"]["needs_convert"] = False
+                elif 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(value)
+                    value_is_set = True
+                    # value is correctly set, remove variable to the set
+                    if index is not None:
+                        # if it's a follower waiting for all followers are sets
+                        self.values[path]["values"][index] = undefined
+                        if set(self.values[path]["values"]) == {undefined}:
+                            self.values.pop(path)
+                    else:
+                        self.values.pop(path)
+                except Exception:
+                    if path != option.path():
+                        self.values[option.path()] = self.values.pop(path)
+            if not value_is_set:
+                break
+
+    def _get_identifier(self, true_name, name) -> str:
+        if true_name == "{{ identifier }}":
+            return name
+        regexp = true_name.replace("{{ identifier }}", "(.*)")
+        finded = findall(regexp, name)
+        if len(finded) != 1 or not finded[0]:
+            return None
+        return finded[0]
+
+    def _populate_error_warnings(self):
+        # we don't find variable, apply value just to get error or warning messages
+        for path, data in self.values.items():
+            try:
+                option = self.config.option(path)
+                value = data["values"]
+                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:
+                self.errors.append(str(err))
+            except (ValueError, LeadershipError) as err:
+                self.errors.append(str(err))
+            except PropertiesOptionError as err:
+                self.warnings.append(str(err))
+
+
+def convert_value(option, value):
+    if value == "":
+        return None
+    option_type = option.information.get("type")
+    if option_type == 'choice':
+        choices = option.value.list()
+        if value not in choices and isinstance(value, str):
+            # FIXME add other tests (boolean, float, ...)
+            if value.isnumeric() and int(value) in choices:
+                value = int(value)
+    func = CONVERT_OPTION.get(option_type, {}).get("func")
+    if func:
+        return func(value)
+    return value

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,3 +0,0 @@
----
-_version: '1.1'
-version:  # a variable

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,3 +0,0 @@
----
-version: '1.0'
-empty:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,10 +0,0 @@
----
-version: 1.1
-var1: "no"  # a first variable
-var2:
-  description: a second variable
-  multi: true
-  default:
-    jinja: |
-      {{ _.var1 }}
-    description: the value of var1

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -12,6 +12,6 @@ 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, notraisepropertyerror=True)})), 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(['../rougail-tests/structures/00_2default_calculated/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.var2"), '_.var1': ParamOption(option_2, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -13,11 +13,11 @@ ALLOWED_LEADER_PROPERTIES.add("advanced")
 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, notraisepropertyerror=True)})), 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(['../rougail-tests/structures/00_2default_calculated/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.var2"), '_.var1': ParamOption(option_3, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 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, notraisepropertyerror=True)})), 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(['../rougail-tests/structures/00_2default_calculated/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.var2"), '_.var1': ParamOption(option_7, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 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/tiramisu/no_namespace.py

@@ -2,11 +2,11 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_var2'] = "{{ _.var1 }}\n"
 option_1 = StrOption(name="var1", doc="a first variable", default="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-option_2 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_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("var2"), '_.var1': ParamOption(option_1, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
+option_2 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['../rougail-tests/structures/00_2default_calculated/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("var2"), '_.var1': ParamOption(option_1, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1, option_2])

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

@@ -1,15 +0,0 @@
----
-version: 1.1
-var1:  # a first variable
-  - 'no'
-  - 'yes'
-  - maybe
-var2:
-  description: a second variable
-  multi: true
-  default:
-    jinja: |
-      {% for val in _.var1 %}
-      {{ val }}
-      {% endfor %}
-    description: the value of _.var1

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -12,6 +12,6 @@ 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, notraisepropertyerror=True)})), 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(['../rougail-tests/structures/00_2default_calculated_multi/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("rougail.var2"), '_.var1': ParamOption(option_2, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -13,11 +13,11 @@ ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_1.rougail.var2'] = "{% for val in _.var1 %}\n{{ val }}\n{% endfor %}\n"
 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, notraisepropertyerror=True)})), 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(['../rougail-tests/structures/00_2default_calculated_multi/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("1.rougail.var2"), '_.var1': ParamOption(option_3, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 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, notraisepropertyerror=True)})), 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(['../rougail-tests/structures/00_2default_calculated_multi/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("2.rougail.var2"), '_.var1': ParamOption(option_7, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 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/no_namespace.py

@@ -2,11 +2,11 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['default_var2'] = "{% for val in _.var1 %}\n{{ val }}\n{% endfor %}\n"
 option_1 = StrOption(name="var1", doc="a first variable", multi=True, default=["no", "yes", "maybe"], default_multi="no", properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
-option_2 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_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("var2"), '_.var1': ParamOption(option_1, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
+option_2 = StrOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_var2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['../rougail-tests/structures/00_2default_calculated_multi/rougail/00-base.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("var2"), '_.var1': ParamOption(option_1, notraisepropertyerror=True)})), properties=frozenset({"mandatory", "standard"}), informations={'type': 'string'})
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1, option_2])

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

@@ -1,15 +0,0 @@
----
-version: 1.1
-
-var1:
-  description: a first variable
-  multi: true
-  type: domainname
-  params:
-    allow_ip: true
-
-var2:
-  description: a second variable
-  default:
-    type: variable
-    variable: _.var1

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -11,6 +11,6 @@ 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'})
+option_3 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_2)), kwargs={'__internal_multi': ParamValue(True)})), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
 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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -11,11 +11,11 @@ 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'})
+option_4 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_3)), kwargs={'__internal_multi': ParamValue(True)})), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
 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'})
+option_8 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_7)), kwargs={'__internal_multi': ParamValue(True)})), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
 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_2default_calculated_variable_transitive/tiramisu/no_namespace.py

@@ -2,10 +2,10 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 option_1 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'domainname'})
-option_2 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_1)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
+option_2 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_1)), kwargs={'__internal_multi': ParamValue(True)})), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'domainname'})
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1, option_2])

tests/dictionaries/00_4load_subfolder/dictionaries/rougail/99-base.yml

@@ -1,4 +0,0 @@
----
-version: '1.0'
-var1:
-  description: a variable

tests/dictionaries/00_4load_subfolder/dictionaries/rougail2/00-base.yml

@@ -1,4 +0,0 @@
----
-version: "1.0"
-var2:
-  description: a variable

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,5 +0,0 @@
----
-version: '1.0'
-without_type:
-  description: a variable
-  default: non

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,18 +0,0 @@
----
-version: '1.1'
-var1: true  # the first variable
-var2:
-  description: the second variable
-  default: true
-var3:
-  description: the third variable
-  type: boolean
-  default: true
-var4: false  # the forth variable
-var5:
-  description: the fifth variable
-  default: false
-var6:
-  description: the sixth variable
-  type: boolean
-  default: false

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,6 +0,0 @@
----
-version: '1.1'
-variable:
-  description: a variable
-  type: boolean
-  mandatory: false

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,42 +0,0 @@
----
-version: '1.1'
-var1:
-  description: the first variable
-  choices:
-    - a
-    - b
-    - c
-var2:
-  description: the second variable
-  choices:
-    - a
-    - b
-    - c
-var3:
-  description: the third variable
-  choices:
-    - a
-    - b
-    - c
-  mandatory: false
-var4:
-  description: the forth variable
-  choices:
-    - null
-    - b
-    - c
-  mandatory: false
-var5:
-  description: the fifth variable
-  choices:
-    - a
-    - b
-    - c
-  default: a
-var6:
-  description: the sixth variable
-  choices:
-    - 1
-    - 2
-    - 3
-  default: 1

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,12 +0,0 @@
----
-version: 1.1
-var:
-  description: a variable
-  default: 9
-  choices:
-    jinja: |
-      {% for n in trange(0, 10) %}
-      {{ n }}
-      {% endfor %}
-    return_type: 'number'
-    description: choices is 0 to 9

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -11,6 +11,6 @@ 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'})
+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(['../rougail-tests/structures/00_6choice_calculation/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", 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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:
@@ -12,10 +12,10 @@ 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'})
+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(['../rougail-tests/structures/00_6choice_calculation/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", 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'})
+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(['../rougail-tests/structures/00_6choice_calculation/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", 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_calculation/tiramisu/no_namespace.py

@@ -2,10 +2,10 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")
 dict_env['choices_var'] = "{% for n in trange(0, 10) %}\n{{ n }}\n{% endfor %}\n"
-option_1 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_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("var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
+option_1 = ChoiceOption(name="var", doc="a variable", values=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("choices_var"), '__internal_type': ParamValue("number"), '__internal_multi': ParamValue(True), '__internal_files': ParamValue(['../rougail-tests/structures/00_6choice_calculation/rougail/00-base.yml']), '__internal_attribute': ParamValue("choices"), '__internal_variable': ParamValue("var")})), default=9, properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice'})
 option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1])

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

@@ -1,11 +0,0 @@
----
-version: '1.1'
-var1:  # a second variable
-  - a
-  - b
-  - c
-var2:
-  description: a first variable
-  default: a
-  choices:
-    variable: _.var1

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,9 +0,0 @@
----
-version: '1.1'
-custom1:
-  description: the first variable
-  type: custom
-custom2:
-  description: the seconf variable
-  type: custom
-  default: value

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,6 +0,0 @@
----
-version: '1.1'
-variable:
-  description: a domain name variable
-  type: domainname
-  default: my.domain.name

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,8 +0,0 @@
----
-version: '1.1'
-variable:
-  description: a domain name variable
-  type: domainname
-  default: my.domain.name
-  params:
-    allow_ip: true

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,18 +0,0 @@
----
-version: '1.1'
-var1: 0.0  # the first variable
-var2:
-  description: the second variable
-  default: 0.0
-var3:
-  description: the third variable
-  type: float
-  default: 0.0
-var4: 10.1  # the forth variable
-var5:
-  description: the fifth variable
-  default: 10.1
-var6:
-  description: the sixth variable
-  type: float
-  default: 10.1

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,18 +0,0 @@
----
-version: '1.1'
-var1: 0  # the first variable
-var2:
-  description: the second variable
-  default: 0
-var3:
-  description: the third variable
-  type: number
-  default: 0
-var4: 10  # this forth variable
-var5:
-  description: the fifth variable
-  default: 10
-var6:
-  description: the sixth variable
-  type: number
-  default: 10

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,13 +0,0 @@
----
-version: '1.1'
-variable1:
-  description: a port variable
-  type: port
-variable2:
-  description: a port variable with default value
-  type: port
-  default: '8080'
-variable3:
-  description: a port variable with integer default value
-  type: port
-  default: 8080

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,9 +0,0 @@
----
-version: '1.1'
-var:
-  description: a first variable
-  regexp: "^#(?:[0-9a-f]{3}){1,2}$"
-  default: "#a1a1a1"
-  test:
-    - "#b1b1b1"
-    - "#b2b2b2"

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")
 ALLOWED_LEADER_PROPERTIES.add("standard")
 ALLOWED_LEADER_PROPERTIES.add("advanced")

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

@@ -1,17 +0,0 @@
----
-version: '1.1'
-var1:  # the first variable
-var2:
-  description: the second variable
-  default:
-var3:
-  description: the third variable
-  type: string
-var4: value  # the forth variable
-var5:
-  description: the fifth variable
-  default: value
-var6:
-  description: the sixth variable
-  type: string
-  default: value

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except:

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

@@ -2,7 +2,7 @@ from tiramisu import *
 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')
+load_functions('../rougail-tests/funcs/test.py')
 try:
     groups.namespace
 except: