diff --git a/docs/fill.rst b/docs/fill.rst index c4b5eca58..af3ba0b54 100644 --- a/docs/fill.rst +++ b/docs/fill.rst @@ -155,7 +155,88 @@ There are two types of parameter: `mandatory` - Name of the information whose value we want to retrieve. - doc - + +The variable path +----------------- + +Normal family +~~~~~~~~~~~~~ + +The default namespace is defined in RougailConfig["variable_namespace"] with the default value "rougail". +In addition, there are extras namespaces defined with in RougailConfig["extra_dictionaries"]. + +Inside those namespaces we can add families and variables. + +Here is an hierarchic examples: + +.. code-block:: + rougail + ├── variable1 + ├── family1 + │ ├── variable2 + │ └── variable3 + └── family2 + └── subfamily1 + └── variable4 + extra1 + └── family3 + ├── variable5 + └── variable6 + +In `calculation` we can use other variables. + +Here is all paths: + +- rougail.variable1 +- rougail.family1.variable2 +- rougail.family1.variable3 +- rougail.family2.subfamily1.variable4 +- extra1.family3.variable5 +- extra1.family3.variable6 + +Inside a variable's `calculation` we can use relative path. "_" means that other variable is in same family. "__" means that other variables are in parent family, and so on... + +For example, in variable2's `calculation`, we can use relative path: + +- __.variable1 +- _.variable3 +- __.family2.subfamily1.variable4 + +But we cannot access to extra1 variables with relative path. + +Dynamic family +~~~~~~~~~~~~~~~~~~ + +Hire is a dynamic family "{{ suffix }}": + +.. code-block:: + rougail + ├── variable1: ["val1", "val2"] + ├── {{ suffix }} + │ ├── variable2 + │ └── variable3 + └── family + └── variable4 + +For variable2's calculation, we can use: + +- rougail.{{ suffix }}.variable3 +- _.variable3 + +In this case, we get value for "variable3" with the same suffix as "variable2". + +For variable4's calculation, we have two possibility: + +- retrieves all values with all suffixes: + + - rougail.{{ suffix }}.variable3 + - __.{{ suffix }}.variable3 + +- retrieves a value for a specified suffix: + + - rougail.val1.variable3 + - __.val1.variable3 + Examples ----------- @@ -235,12 +316,12 @@ An example with parameters: param1: value param2: type: variable - variable: rougail.unknown_variable + variable: _.unknown_variable optional: true param3: type: information information: doc - variable: rougail.my_calculated_variable + variable: _.my_calculated_variable An example with a `suffix` type parameter: @@ -257,7 +338,7 @@ An example with a `suffix` type parameter: type: dynamic dynamic: type: variable - variable: rougail.varname + variable: _.varname description: 'Describe ' my_dyn_var: type: string @@ -311,7 +392,7 @@ Copy a variable in another: multi: true default: type: variable - variable: rougail.my_variable + variable: _.my_variable Copy one variable to another if the source has no `property` problem: @@ -326,7 +407,7 @@ Copy one variable to another if the source has no `property` problem: multi: true default: type: variable - variable: rougail.my_variable + variable: _.my_variable propertyerror: false Copy two non-multiple variables into a multiple variable: @@ -343,9 +424,9 @@ Copy two non-multiple variables into a multiple variable: multi: true default: - type: variable - variable: rougail.my_variable_1 + variable: _.my_variable_1 - type: variable - variable: rougail.my_variable_2 + variable: _.my_variable_2 A variable in a dynamic family can also be used in a calculation. @@ -364,7 +445,7 @@ For example using the variable for a particular suffix: type: dynamic dynamic: type: variable - variable: rougail.varname + variable: _.varname description: 'Describe ' my_dyn_var_: type: string @@ -373,7 +454,7 @@ For example using the variable for a particular suffix: all_dyn_var: default: type: variable - variable: rougail.my_dyn_family_val1.my_dyn_var_val1 + variable: _.my_dyn_family_val1.my_dyn_var_val1 In this case, we recover the value `val1`. @@ -392,7 +473,7 @@ Second example using the variable for all suffixes: type: dynamic dynamic: type: variable - variable: rougail.varname + variable: _.varname description: 'Describe ' my_dyn_var_: type: string @@ -402,7 +483,7 @@ Second example using the variable for all suffixes: multi: true default: type: variable - variable: rougail.my_dyn_family_.my_dyn_var_ + variable: _.my_dyn_family_.my_dyn_var_ In this case, we recover the `val1` and `val2` list. @@ -422,7 +503,7 @@ Calculation via a suffix type: dynamic dynamic: type: variable - variable: rougail.varname + variable: _.varname description: 'Describe ' my_dyn_var_: type: string diff --git a/src/rougail/convert.py b/src/rougail/convert.py index 0f6a59217..7176f42a5 100644 --- a/src/rougail/convert.py +++ b/src/rougail/convert.py @@ -42,7 +42,7 @@ from typing import ( Tuple, ) from itertools import chain -from re import findall +from re import findall, compile from yaml import safe_load from pydantic import ValidationError @@ -97,6 +97,8 @@ class Property: class Paths: + _regexp_relative = compile(r"^_*\.(.*)$") + def __init__(self) -> None: self._data: Dict[str, Union[Variable, Family]] = {} self._dynamics: List[str] = [] @@ -110,6 +112,7 @@ class Paths: path: str, data: Any, is_dynamic: bool, + *, force: bool = False, ) -> None: self._data[path] = data @@ -119,24 +122,34 @@ class Paths: def get_with_dynamic( self, path: str, + suffix_path: str, + current_path: str, ) -> Any: suffix = None + if self._regexp_relative.search(path): + relative, subpath = path.split(".", 1) + relative_len = len(relative) + path_len = current_path.count(".") + parent_path = current_path.rsplit(".", relative_len)[0] + path = parent_path + "." + subpath + else: + path = get_realpath(path, suffix_path) dynamic_path = None dynamic_variable_path = None if not path in self._data: for dynamic in self._dynamics: if "{{ suffix }}" in dynamic: - regexp = "^" + dynamic.replace('{{ suffix }}', '(.*)') + '.' + regexp = "^" + dynamic.replace("{{ suffix }}", "(.*)") + "." finded = findall(regexp, path) if len(finded) != 1: continue - splitted_dynamic = dynamic.split('.') - splitted_path = path.split('.') + splitted_dynamic = dynamic.split(".") + splitted_path = path.split(".") for idx, s in enumerate(splitted_dynamic): - if '{{ suffix }}' in s: + if "{{ suffix }}" in s: break - suffix_path = '.'.join(splitted_path[idx + 1:]) + suffix_path = ".".join(splitted_path[idx + 1 :]) if suffix_path: suffix_path = "." + suffix_path suffix = splitted_path[idx] + suffix_path @@ -478,6 +491,9 @@ class ParserVariable: ): # it's a dict, so a new variables! continue + # FIXME should be remove with 1.0 format + if key == "variable" and obj.get("type") != "dynamic": + continue if key in self.family_attrs: yield key diff --git a/src/rougail/object_model.py b/src/rougail/object_model.py index a5b43d6cb..4ad30b314 100644 --- a/src/rougail/object_model.py +++ b/src/rougail/object_model.py @@ -148,11 +148,12 @@ class Calculation(BaseModel): for param_obj in self.params: param = param_obj.model_dump() if param.get("type") == "variable": - variable_path = self.get_realpath(param["variable"]) - variable, suffix, dynamic = objectspace.paths.get_with_dynamic(variable_path) + variable, suffix, dynamic = objectspace.paths.get_with_dynamic( + param["variable"], self.path_prefix, self.path + ) if not variable: if not param.get("optional"): - raise Exception(f"cannot find {variable_path}") + raise Exception(f"cannot find {param['variable']}") continue if not isinstance(variable, objectspace.variable): raise Exception("pfff it's a family") @@ -162,10 +163,15 @@ class Calculation(BaseModel): param["dynamic"] = dynamic if param.get("type") == "information": if param["variable"]: - variable_path = self.get_realpath(param["variable"]) - param["variable"] = objectspace.paths[variable_path] - if not param["variable"]: + variable, suffix, dynamic = objectspace.paths.get_with_dynamic( + param["variable"], self.path_prefix, self.path + ) + # variable_path = self.get_realpath(param["variable"]) + if not variable: raise Exception("pffff") + param["variable"] = variable + if suffix: + raise Exception("pff not dynamic with information") else: del param["variable"] params[param.pop("key")] = param @@ -212,6 +218,7 @@ class JinjaCalculation(Calculation): if params: default["params"] |= params for sub_variable, suffix, true_path, dynamic in get_jinja_variable_to_param( + self.path, self.jinja, objectspace, variable.xmlfiles, @@ -300,8 +307,9 @@ class VariableCalculation(Calculation): self, objectspace, ) -> dict: - variable_path = self.get_realpath(self.variable) - variable, suffix, dynamic = objectspace.paths.get_with_dynamic(variable_path) + variable, suffix, dynamic = objectspace.paths.get_with_dynamic( + self.variable, self.path_prefix, self.path + ) if not variable: raise VariableNotFoundError(f"Variable not found {variable_path}", variable_path) if not isinstance(variable, objectspace.variable): @@ -325,11 +333,7 @@ class VariableCalculation(Calculation): raise Exception("only boolean!") params[None].insert(0, self.attribute_name) if not self.inside_list and self.path in objectspace.multis: - if ( - not objectspace.paths.is_dynamic(variable_path) - and variable_path not in objectspace.multis - ): - params["multi"] = True + variable_path = self.get_realpath(self.variable) params["allow_none"] = True if self.inside_list and variable.path in objectspace.multis: raise Exception("pfff") diff --git a/src/rougail/path.py b/src/rougail/path.py deleted file mode 100644 index a9ce34bb9..000000000 --- a/src/rougail/path.py +++ /dev/null @@ -1,527 +0,0 @@ -"""Manage path to find objects - -Created by: -EOLE (http://eole.orion.education.fr) -Copyright (C) 2005-2018 - -Forked by: -Cadoles (http://www.cadoles.com) -Copyright (C) 2019-2021 - -Silique (https://www.silique.fr) -Copyright (C) 2022-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 .i18n import _ -from .error import DictConsistencyError -from .utils import normalize_family - - -class Path: - """Helper class to handle the `path` attribute. - - sample: path="creole.general.condition" - """ - - def __init__( - self, - rougailconfig: "RougailConfig", - ) -> None: - self.variables = {} - self.families = {} - # self.names = {} - self.full_paths_families = {} - self.full_paths_variables = {} - self.full_dyn_paths_families = {} - self.valid_enums = {} - self.variable_namespace = rougailconfig["variable_namespace"] - self.providers = {} - self.suppliers = {} - self.list_conditions = {} - self.suffix = rougailconfig["suffix"] - self.index = 0 - - def set_path_prefix(self, prefix: str) -> None: - self._path_prefix = prefix - if prefix: - if None in self.full_paths_families: - raise DictConsistencyError( - _(f'prefix "{prefix}" cannot be set if a prefix "None" exists'), - 39, - None, - ) - else: - for old_prefix in self.full_paths_families: - if old_prefix != None: - raise DictConsistencyError( - _(f"no prefix cannot be set if a prefix exists"), 84, None - ) - if prefix in self.full_paths_families: - raise DictConsistencyError(_(f'prefix "{prefix}" already exists'), 83, None) - self.full_paths_families[prefix] = {} - self.full_paths_variables[prefix] = {} - self.valid_enums[prefix] = {} - self.providers[prefix] = {} - self.suppliers[prefix] = {} - self.list_conditions[prefix] = {} - - def has_path_prefix(self) -> bool: - return None not in self.full_paths_families - - def get_path_prefixes(self) -> list: - return list(self.full_paths_families) - - def get_path_prefix(self) -> str: - return self._path_prefix - - # Family - def add_family( - self, - namespace: str, - subpath: str, - variableobj: str, - is_dynamic: str, - force_path_prefix: str = None, - ) -> str: # pylint: disable=C0111 - """Add a new family""" - if force_path_prefix is None: - force_path_prefix = self._path_prefix - path = subpath + "." + variableobj.name - if namespace == self.variable_namespace: - if variableobj.name in self.full_paths_families[force_path_prefix]: - msg = _(f'Duplicate family name "{variableobj.name}"') - raise DictConsistencyError(msg, 55, variableobj.xmlfiles) - self.full_paths_families[force_path_prefix][variableobj.name] = path - if is_dynamic: - if subpath in self.full_dyn_paths_families: - dyn_subpath = self.full_dyn_paths_families[subpath] - else: - dyn_subpath = subpath - self.full_dyn_paths_families[ - path - ] = f"{dyn_subpath}.{variableobj.name}{{suffix}}" - if path in self.families: - msg = _(f'Duplicate family name "{path}"') - raise DictConsistencyError(msg, 37, variableobj.xmlfiles) - if path in self.variables: - msg = _(f'A variable and a family has the same path "{path}"') - raise DictConsistencyError(msg, 56, variableobj.xmlfiles) - self.families[path] = dict( - name=path, - namespace=namespace, - variableobj=variableobj, - ) - self.set_name(variableobj, "optiondescription_") - variableobj.path = path - variableobj.path_prefix = force_path_prefix - - def get_family( - self, - path: str, - current_namespace: str, - path_prefix: str, - allow_variable_namespace: bool = False, - ) -> "Family": # pylint: disable=C0111 - """Get a family""" - if ( - current_namespace == self.variable_namespace or allow_variable_namespace - ) and path in self.full_paths_families[path_prefix]: - path = self.full_paths_families[path_prefix][path] - elif allow_variable_namespace and path_prefix: - path = f"{path_prefix}.{path}" - if path not in self.families: - raise DictConsistencyError(_(f'unknown option "{path}"'), 42, []) - dico = self.families[path] - if current_namespace != dico["namespace"] and ( - not allow_variable_namespace or current_namespace != self.variable_namespace - ): - msg = _( - f'A family located in the "{dico["namespace"]}" namespace ' - f'shall not be used in the "{current_namespace}" namespace' - ) - raise DictConsistencyError(msg, 38, []) - return dico["variableobj"] - - def _get_dyn_path( - self, - subpath: str, - name: bool, - ) -> str: - if subpath in self.full_dyn_paths_families: - subpath = self.full_dyn_paths_families[subpath] - path = f"{subpath}.{name}{{suffix}}" - else: - path = f"{subpath}.{name}" - return path - - def set_provider( - self, - variableobj, - name, - family, - ): - if not hasattr(variableobj, "provider"): - return - p_name = "provider:" + variableobj.provider - if "." in name: - msg = f'provider "{p_name}" not allowed in extra' - raise DictConsistencyError(msg, 82, variableobj.xmlfiles) - if p_name in self.providers[variableobj.path_prefix]: - msg = f'provider "{p_name}" declare multiple time' - raise DictConsistencyError(msg, 79, variableobj.xmlfiles) - self.providers[variableobj.path_prefix][p_name] = { - "path": self._get_dyn_path( - family, - name, - ), - "option": variableobj, - } - - def get_provider( - self, - name: str, - path_prefix: str = None, - ) -> "self.objectspace.variable": - return self.providers[path_prefix][name]["option"] - - def get_providers_path(self, path_prefix=None): - if path_prefix: - return { - name: option["path"].split(".", 1)[-1] - for name, option in self.providers[path_prefix].items() - } - return { - name: option["path"] for name, option in self.providers[path_prefix].items() - } - - def set_supplier( - self, - variableobj, - name, - family, - ): - if not hasattr(variableobj, "supplier"): - return - s_name = "supplier:" + variableobj.supplier - if "." in name: - msg = f'supplier "{s_name}" not allowed in extra' - raise DictConsistencyError(msg, 82, variableobj.xmlfiles) - if s_name in self.suppliers[variableobj.path_prefix]: - msg = f'supplier "{s_name}" declare multiple time' - raise DictConsistencyError(msg, 79, variableobj.xmlfiles) - self.suppliers[variableobj.path_prefix][s_name] = { - "path": self._get_dyn_path(family, name), - "option": variableobj, - } - - def get_supplier( - self, - name: str, - path_prefix: str = None, - ) -> "self.objectspace.variable": - return self.suppliers[path_prefix][name]["option"] - - def get_suppliers_path(self, path_prefix=None): - if path_prefix: - return { - name: option["path"].split(".", 1)[-1] - for name, option in self.suppliers[path_prefix].items() - } - return { - name: option["path"] for name, option in self.suppliers[path_prefix].items() - } - - # Variable - def add_variable( - self, # pylint: disable=R0913 - namespace: str, - subpath: str, - variableobj: "self.objectspace.variable", - is_dynamic: bool = False, - is_leader: bool = False, - force_path_prefix: str = None, - ) -> str: # pylint: disable=C0111 - """Add a new variable (with path)""" - if force_path_prefix is None: - force_path_prefix = self._path_prefix - path = subpath + "." + variableobj.name - if namespace == self.variable_namespace: - self.full_paths_variables[force_path_prefix][variableobj.name] = path - if path in self.families: - msg = _(f'A family and a variable has the same path "{path}"') - raise DictConsistencyError(msg, 57, variableobj.xmlfiles) - if is_leader: - leader = subpath - else: - leader = None - self.variables[path] = dict( - name=path, - family=subpath, - leader=leader, - is_dynamic=is_dynamic, - variableobj=variableobj, - ) - variableobj.path = path - variableobj.path_prefix = force_path_prefix - self.set_name(variableobj, "option_") - - def set_name( - self, - variableobj, - option_prefix, - ): - self.index += 1 - variableobj.reflector_name = f"{option_prefix}{self.index}{self.suffix}" - - def get_variable( - self, - name: str, - namespace: str, - xmlfiles: List[str] = [], - allow_variable_namespace: bool = False, - force_path_prefix: str = None, - add_path_prefix: bool = False, - ) -> "Variable": # pylint: disable=C0111 - """Get variable object from a path""" - if force_path_prefix is None: - force_path_prefix = self._path_prefix - try: - variable, suffix = self._get_variable( - name, - namespace, - with_suffix=True, - xmlfiles=xmlfiles, - path_prefix=force_path_prefix, - add_path_prefix=add_path_prefix, - ) - except DictConsistencyError as err: - if ( - not allow_variable_namespace - or err.errno != 42 - or namespace == self.variable_namespace - ): - raise err from err - variable, suffix = self._get_variable( - name, - self.variable_namespace, - with_suffix=True, - xmlfiles=xmlfiles, - path_prefix=force_path_prefix, - ) - if suffix: - raise DictConsistencyError(_(f"{name} is a dynamic variable"), 36, []) - return variable["variableobj"] - - def get_variable_family_path( - self, - name: str, - namespace: str, - xmlfiles: List[str] = False, - force_path_prefix: str = None, - ) -> str: # pylint: disable=C0111 - """Get the full path of a family""" - if force_path_prefix is None: - force_path_prefix = self._path_prefix - return self._get_variable( - name, - namespace, - xmlfiles=xmlfiles, - path_prefix=force_path_prefix, - )["family"] - - def get_variable_with_suffix( - self, - name: str, - current_namespace: str, - xmlfiles: List[str], - path_prefix: str, - ) -> str: # pylint: disable=C0111 - """get full path of a variable""" - try: - dico, suffix = self._get_variable( - name, - current_namespace, - with_suffix=True, - xmlfiles=xmlfiles, - path_prefix=path_prefix, - add_path_prefix=True, - ) - except DictConsistencyError as err: - if err.errno != 42 or current_namespace == self.variable_namespace: - raise err from err - dico, suffix = self._get_variable( - name, - self.variable_namespace, - with_suffix=True, - xmlfiles=xmlfiles, - path_prefix=path_prefix, - add_path_prefix=True, - ) - namespace = dico["variableobj"].namespace - if ( - namespace not in [self.variable_namespace, "services"] - and current_namespace != "services" - and current_namespace != namespace - ): - msg = _( - f'A variable located in the "{namespace}" namespace shall not be used ' - f'in the "{current_namespace}" namespace' - ) - raise DictConsistencyError(msg, 41, xmlfiles) - return dico["variableobj"], suffix - - def path_is_defined( - self, - path: str, - namespace: str, - force_path_prefix: str = None, - ) -> str: # pylint: disable=C0111 - """The path is a valid path""" - if namespace == self.variable_namespace: - if force_path_prefix is None: - force_path_prefix = self._path_prefix - return path in self.full_paths_variables[force_path_prefix] - return path in self.variables - - def get_path( - self, - path: str, - namespace: str, - ) -> str: - if namespace == self.variable_namespace: - if path not in self.full_paths_variables[self._path_prefix]: - return None - path = self.full_paths_variables[self._path_prefix][path] - else: - path = f"{self._path_prefix}.{path}" - return path - - def is_dynamic(self, variableobj) -> bool: - """This variable is in dynamic family""" - return self._get_variable( - variableobj.path, - variableobj.namespace, - path_prefix=variableobj.path_prefix, - )["is_dynamic"] - - def is_leader(self, variableobj): # pylint: disable=C0111 - """Is the variable is a leader""" - path = variableobj.path - variable = self._get_variable( - path, - variableobj.namespace, - path_prefix=variableobj.path_prefix, - ) - if not variable["leader"]: - return False - leadership = self.get_family( - variable["leader"], - variableobj.namespace, - path_prefix=variableobj.path_prefix, - ) - return next(iter(leadership.variable.values())).path == path - - def is_follower(self, variableobj) -> bool: - """Is the variable is a follower""" - variable = self._get_variable( - variableobj.path, - variableobj.namespace, - path_prefix=variableobj.path_prefix, - ) - if not variable["leader"]: - return False - leadership = self.get_family( - variable["leader"], - variableobj.namespace, - path_prefix=variableobj.path_prefix, - ) - return next(iter(leadership.variable.values())).path != variableobj.path - - def get_leader(self, variableobj) -> str: - variable = self._get_variable( - variableobj.path, - variableobj.namespace, - path_prefix=variableobj.path_prefix, - ) - if not variable["leader"]: - raise Exception(f"cannot find leader for {variableobj.path}") - leadership = self.get_family( - variable["leader"], - variableobj.namespace, - path_prefix=variableobj.path_prefix, - ) - return next(iter(leadership.variable.values())) - - def _get_variable( - self, - path: str, - namespace: str, - with_suffix: bool = False, - xmlfiles: List[str] = [], - path_prefix: str = None, - add_path_prefix: bool = False, - ) -> str: - if namespace == self.variable_namespace: - if path in self.full_paths_variables[path_prefix]: - path = self.full_paths_variables[path_prefix][path] - else: - if with_suffix: - for var_name, full_path in self.full_paths_variables[ - path_prefix - ].items(): - if not path.startswith(var_name): - continue - variable = self._get_variable( - full_path, namespace, path_prefix=path_prefix - ) - if not variable["is_dynamic"]: - continue - return variable, path[len(var_name) :] - if path_prefix and add_path_prefix: - path = f"{path_prefix}.{path}" - elif path_prefix and add_path_prefix: - path = f"{path_prefix}.{path}" - # FIXME with_suffix and variable in extra? - if path not in self.variables: - raise DictConsistencyError(_(f'unknown option "{path}"'), 42, xmlfiles) - if with_suffix: - return self.variables[path], None - return self.variables[path] - - def set_valid_enums( - self, - path, - values, - path_prefix, - ): - self.valid_enums[path_prefix][path] = values - - def has_valid_enums( - self, - path: str, - path_prefix: str, - ) -> bool: - return path in self.valid_enums[path_prefix] - - def get_valid_enums( - self, - path: str, - path_prefix: str, - ): - return self.valid_enums[path_prefix][path] diff --git a/src/rougail/utils.py b/src/rougail/utils.py index 608857d70..f4ca70930 100644 --- a/src/rougail/utils.py +++ b/src/rougail/utils.py @@ -87,6 +87,7 @@ def get_realpath( def get_jinja_variable_to_param( + current_path: str, jinja_text, objectspace, xmlfiles, @@ -113,7 +114,9 @@ def get_jinja_variable_to_param( variables.sort() for variable_path in variables: variable, suffix, dynamic = objectspace.paths.get_with_dynamic( - get_realpath(variable_path, path_prefix) + variable_path, + path_prefix, + current_path, ) if variable and variable.path in objectspace.variables: yield variable, suffix, variable_path, dynamic diff --git a/tests/dictionaries/10check_variable_relative/__init__.py b/tests/dictionaries/10check_variable_relative/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/10check_variable_relative/dictionaries/rougail/00-base.yml b/tests/dictionaries/10check_variable_relative/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..9a33666a0 --- /dev/null +++ b/tests/dictionaries/10check_variable_relative/dictionaries/rougail/00-base.yml @@ -0,0 +1,11 @@ +--- +version: '1.0' +general: + var: + type: number + validators: + - type: jinja + jinja: | + {% if _.var > 10 %} + to high + {% endif %} diff --git a/tests/dictionaries/10check_variable_relative/makedict/after.json b/tests/dictionaries/10check_variable_relative/makedict/after.json new file mode 100644 index 000000000..983a136fe --- /dev/null +++ b/tests/dictionaries/10check_variable_relative/makedict/after.json @@ -0,0 +1,6 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10check_variable_relative/makedict/base.json b/tests/dictionaries/10check_variable_relative/makedict/base.json new file mode 100644 index 000000000..78f30ee1e --- /dev/null +++ b/tests/dictionaries/10check_variable_relative/makedict/base.json @@ -0,0 +1,3 @@ +{ + "rougail.general.var": null +} diff --git a/tests/dictionaries/10check_variable_relative/makedict/before.json b/tests/dictionaries/10check_variable_relative/makedict/before.json new file mode 100644 index 000000000..983a136fe --- /dev/null +++ b/tests/dictionaries/10check_variable_relative/makedict/before.json @@ -0,0 +1,6 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10check_variable_relative/makedict/mandatory.json b/tests/dictionaries/10check_variable_relative/makedict/mandatory.json new file mode 100644 index 000000000..c15f7f7e4 --- /dev/null +++ b/tests/dictionaries/10check_variable_relative/makedict/mandatory.json @@ -0,0 +1 @@ +["rougail.general.var"] \ No newline at end of file diff --git a/tests/dictionaries/10check_variable_relative/tiramisu/base.py b/tests/dictionaries/10check_variable_relative/tiramisu/base.py new file mode 100644 index 000000000..0a3766573 --- /dev/null +++ b/tests/dictionaries/10check_variable_relative/tiramisu/base.py @@ -0,0 +1,73 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['validators_rougail.general.var'] = "{% if _.var > 10 %}\nto high\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = IntOption(name="var", doc="var", validators=[Calculation(func['valid_with_jinja'], Params((), kwargs={'__internal_jinja': ParamValue("validators_rougail.general.var"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '_.var': ParamSelfOption(whole=False)}))], properties=frozenset({"basic", "mandatory"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"basic"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/10check_variable_relative/tiramisu/multi.py b/tests/dictionaries/10check_variable_relative/tiramisu/multi.py new file mode 100644 index 000000000..96d67b1df --- /dev/null +++ b/tests/dictionaries/10check_variable_relative/tiramisu/multi.py @@ -0,0 +1,79 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['validators_1.rougail.general.var'] = "{% if _.var > 10 %}\nto high\n{% endif %}\n" +dict_env['validators_2.rougail.general.var'] = "{% if _.var > 10 %}\nto high\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = IntOption(name="var", doc="var", validators=[Calculation(func['valid_with_jinja'], Params((), kwargs={'__internal_jinja': ParamValue("validators_1.rougail.general.var"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '_.var': ParamSelfOption(whole=False)}))], properties=frozenset({"basic", "mandatory"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4], properties=frozenset({"basic"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"})) +option_8 = IntOption(name="var", doc="var", validators=[Calculation(func['valid_with_jinja'], Params((), kwargs={'__internal_jinja': ParamValue("validators_2.rougail.general.var"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '_.var': ParamSelfOption(whole=False)}))], properties=frozenset({"basic", "mandatory"})) +optiondescription_7 = OptionDescription(name="general", doc="general", children=[option_8], properties=frozenset({"basic"})) +optiondescription_6 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_7], 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]) diff --git a/tests/dictionaries/10disabled_with_variable_relative/__init__.py b/tests/dictionaries/10disabled_with_variable_relative/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/10disabled_with_variable_relative/dictionaries/rougail/00-base.yml b/tests/dictionaries/10disabled_with_variable_relative/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..af47c6e73 --- /dev/null +++ b/tests/dictionaries/10disabled_with_variable_relative/dictionaries/rougail/00-base.yml @@ -0,0 +1,8 @@ +version: '1.0' +condition: + type: boolean +variable: + disabled: + type: variable + variable: _.condition + mandatory: false diff --git a/tests/dictionaries/10disabled_with_variable_relative/makedict/after.json b/tests/dictionaries/10disabled_with_variable_relative/makedict/after.json new file mode 100644 index 000000000..5995efe9d --- /dev/null +++ b/tests/dictionaries/10disabled_with_variable_relative/makedict/after.json @@ -0,0 +1,6 @@ +{ + "rougail.condition": { + "owner": "default", + "value": true + } +} diff --git a/tests/dictionaries/10disabled_with_variable_relative/makedict/base.json b/tests/dictionaries/10disabled_with_variable_relative/makedict/base.json new file mode 100644 index 000000000..18b52facb --- /dev/null +++ b/tests/dictionaries/10disabled_with_variable_relative/makedict/base.json @@ -0,0 +1,3 @@ +{ + "rougail.condition": true +} diff --git a/tests/dictionaries/10disabled_with_variable_relative/makedict/before.json b/tests/dictionaries/10disabled_with_variable_relative/makedict/before.json new file mode 100644 index 000000000..5995efe9d --- /dev/null +++ b/tests/dictionaries/10disabled_with_variable_relative/makedict/before.json @@ -0,0 +1,6 @@ +{ + "rougail.condition": { + "owner": "default", + "value": true + } +} diff --git a/tests/dictionaries/10disabled_with_variable_relative/makedict/mandatory.json b/tests/dictionaries/10disabled_with_variable_relative/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/10disabled_with_variable_relative/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/10disabled_with_variable_relative/tiramisu/base.py b/tests/dictionaries/10disabled_with_variable_relative/tiramisu/base.py new file mode 100644 index 000000000..9e05b328d --- /dev/null +++ b/tests/dictionaries/10disabled_with_variable_relative/tiramisu/base.py @@ -0,0 +1,72 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_2 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_3 = StrOption(name="variable", doc="variable", properties=frozenset({"standard", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_2))), help_function=func['variable_to_property'])})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[option_2, option_3], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/10disabled_with_variable_relative/tiramisu/multi.py b/tests/dictionaries/10disabled_with_variable_relative/tiramisu/multi.py new file mode 100644 index 000000000..7affbab33 --- /dev/null +++ b/tests/dictionaries/10disabled_with_variable_relative/tiramisu/multi.py @@ -0,0 +1,77 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_4 = StrOption(name="variable", doc="variable", properties=frozenset({"standard", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_3))), help_function=func['variable_to_property'])})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[option_3, option_4], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_7 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_8 = StrOption(name="variable", doc="variable", properties=frozenset({"standard", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_7))), help_function=func['variable_to_property'])})) +optiondescription_6 = OptionDescription(name="rougail", doc="rougail", 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]) diff --git a/tests/dictionaries/10fill_optional/dictionaries/rougail/00-base.yml b/tests/dictionaries/10fill_optional/dictionaries/rougail/00-base.yml index 8cbfce623..50722911e 100644 --- a/tests/dictionaries/10fill_optional/dictionaries/rougail/00-base.yml +++ b/tests/dictionaries/10fill_optional/dictionaries/rougail/00-base.yml @@ -1,3 +1,4 @@ +--- version: '1.0' general: mode_conteneur_actif: @@ -7,19 +8,12 @@ general: default: type: jinja jinja: '{% if __mode_conteneur_actif4 is defined %} - {{ __mode_conteneur_actif4 }} - {% elif __mode_conteneur_actif3 is defined %} - {{ __mode_conteneur_actif3 }} - {% else %} - {{ rougail.general.mode_conteneur_actif1 }} - {% endif %} - ' params: __mode_conteneur_actif4: diff --git a/tests/dictionaries/10fill_optional/tiramisu/base.py b/tests/dictionaries/10fill_optional/tiramisu/base.py index 522738d53..ccdc0b212 100644 --- a/tests/dictionaries/10fill_optional/tiramisu/base.py +++ b/tests/dictionaries/10fill_optional/tiramisu/base.py @@ -63,7 +63,7 @@ func['jinja_to_property_help'] = jinja_to_property_help func['variable_to_property'] = variable_to_property func['valid_with_jinja'] = valid_with_jinja dict_env = {} -dict_env['default_rougail.general.mode_conteneur_actif'] = "{% if __mode_conteneur_actif4 is defined %}\n{{ __mode_conteneur_actif4 }}\n{% elif __mode_conteneur_actif3 is defined %}\n{{ __mode_conteneur_actif3 }}\n{% else %}\n{{ rougail.general.mode_conteneur_actif1 }}\n{% endif %}\n" +dict_env['default_rougail.general.mode_conteneur_actif'] = "{% if __mode_conteneur_actif4 is defined %} {{ __mode_conteneur_actif4 }} {% elif __mode_conteneur_actif3 is defined %} {{ __mode_conteneur_actif3 }} {% else %} {{ rougail.general.mode_conteneur_actif1 }} {% endif %} " ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) ENV.filters = func ENV.compile_templates('jinja_caches', zip=None) diff --git a/tests/dictionaries/10fill_optional/tiramisu/multi.py b/tests/dictionaries/10fill_optional/tiramisu/multi.py index dbeb123fe..8ad9eb5ca 100644 --- a/tests/dictionaries/10fill_optional/tiramisu/multi.py +++ b/tests/dictionaries/10fill_optional/tiramisu/multi.py @@ -63,8 +63,8 @@ func['jinja_to_property_help'] = jinja_to_property_help func['variable_to_property'] = variable_to_property func['valid_with_jinja'] = valid_with_jinja dict_env = {} -dict_env['default_1.rougail.general.mode_conteneur_actif'] = "{% if __mode_conteneur_actif4 is defined %}\n{{ __mode_conteneur_actif4 }}\n{% elif __mode_conteneur_actif3 is defined %}\n{{ __mode_conteneur_actif3 }}\n{% else %}\n{{ rougail.general.mode_conteneur_actif1 }}\n{% endif %}\n" -dict_env['default_2.rougail.general.mode_conteneur_actif'] = "{% if __mode_conteneur_actif4 is defined %}\n{{ __mode_conteneur_actif4 }}\n{% elif __mode_conteneur_actif3 is defined %}\n{{ __mode_conteneur_actif3 }}\n{% else %}\n{{ rougail.general.mode_conteneur_actif1 }}\n{% endif %}\n" +dict_env['default_1.rougail.general.mode_conteneur_actif'] = "{% if __mode_conteneur_actif4 is defined %} {{ __mode_conteneur_actif4 }} {% elif __mode_conteneur_actif3 is defined %} {{ __mode_conteneur_actif3 }} {% else %} {{ rougail.general.mode_conteneur_actif1 }} {% endif %} " +dict_env['default_2.rougail.general.mode_conteneur_actif'] = "{% if __mode_conteneur_actif4 is defined %} {{ __mode_conteneur_actif4 }} {% elif __mode_conteneur_actif3 is defined %} {{ __mode_conteneur_actif3 }} {% else %} {{ rougail.general.mode_conteneur_actif1 }} {% endif %} " ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) ENV.filters = func ENV.compile_templates('jinja_caches', zip=None) diff --git a/tests/dictionaries/10load_mandatory_relative_path/__init__.py b/tests/dictionaries/10load_mandatory_relative_path/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/10load_mandatory_relative_path/dictionaries/rougail/00-base.yml b/tests/dictionaries/10load_mandatory_relative_path/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..acdc13d64 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path/dictionaries/rougail/00-base.yml @@ -0,0 +1,13 @@ +--- +version: '1.0' +general: + condition: + type: boolean + default: true + mode_conteneur_actif: + mandatory: + type: jinja + jinja: | + {% if _.condition == "yes" %} + condition is yes + {% endif %} diff --git a/tests/dictionaries/10load_mandatory_relative_path/makedict/after.json b/tests/dictionaries/10load_mandatory_relative_path/makedict/after.json new file mode 100644 index 000000000..5d5ce8188 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path/makedict/after.json @@ -0,0 +1,10 @@ +{ + "rougail.general.condition": { + "owner": "default", + "value": true + }, + "rougail.general.mode_conteneur_actif": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10load_mandatory_relative_path/makedict/base.json b/tests/dictionaries/10load_mandatory_relative_path/makedict/base.json new file mode 100644 index 000000000..4ec5f8013 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path/makedict/base.json @@ -0,0 +1,4 @@ +{ + "rougail.general.condition": true, + "rougail.general.mode_conteneur_actif": null +} diff --git a/tests/dictionaries/10load_mandatory_relative_path/makedict/before.json b/tests/dictionaries/10load_mandatory_relative_path/makedict/before.json new file mode 100644 index 000000000..5d5ce8188 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path/makedict/before.json @@ -0,0 +1,10 @@ +{ + "rougail.general.condition": { + "owner": "default", + "value": true + }, + "rougail.general.mode_conteneur_actif": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10load_mandatory_relative_path/makedict/mandatory.json b/tests/dictionaries/10load_mandatory_relative_path/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/10load_mandatory_relative_path/tiramisu/base.py b/tests/dictionaries/10load_mandatory_relative_path/tiramisu/base.py new file mode 100644 index 000000000..ed8e34ac0 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path/tiramisu/base.py @@ -0,0 +1,74 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['mandatory_rougail.general.mode_conteneur_actif'] = "{% if _.condition == \"yes\" %}\ncondition is yes\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_4 = StrOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", properties=frozenset({"standard", Calculation(func['jinja_to_property'], Params((ParamValue("mandatory")), kwargs={'__internal_jinja': ParamValue("mandatory_rougail.general.mode_conteneur_actif"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '_.condition': ParamOption(option_3)}), help_function=func['jinja_to_property_help'])})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, option_4], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/10load_mandatory_relative_path/tiramisu/multi.py b/tests/dictionaries/10load_mandatory_relative_path/tiramisu/multi.py new file mode 100644 index 000000000..4663ff63a --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path/tiramisu/multi.py @@ -0,0 +1,81 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['mandatory_1.rougail.general.mode_conteneur_actif'] = "{% if _.condition == \"yes\" %}\ncondition is yes\n{% endif %}\n" +dict_env['mandatory_2.rougail.general.mode_conteneur_actif'] = "{% if _.condition == \"yes\" %}\ncondition is yes\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_5 = StrOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", properties=frozenset({"standard", Calculation(func['jinja_to_property'], Params((ParamValue("mandatory")), kwargs={'__internal_jinja': ParamValue("mandatory_1.rougail.general.mode_conteneur_actif"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '_.condition': ParamOption(option_4)}), help_function=func['jinja_to_property_help'])})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, option_5], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_9 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_10 = StrOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", properties=frozenset({"standard", Calculation(func['jinja_to_property'], Params((ParamValue("mandatory")), kwargs={'__internal_jinja': ParamValue("mandatory_2.rougail.general.mode_conteneur_actif"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '_.condition': ParamOption(option_9)}), help_function=func['jinja_to_property_help'])})) +optiondescription_8 = OptionDescription(name="general", doc="general", children=[option_9, option_10], properties=frozenset({"standard"})) +optiondescription_7 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_8], properties=frozenset({"standard"})) +optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6]) diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/__init__.py b/tests/dictionaries/10load_mandatory_relative_path_variable/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/dictionaries/rougail/00-base.yml b/tests/dictionaries/10load_mandatory_relative_path_variable/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..c52db5443 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path_variable/dictionaries/rougail/00-base.yml @@ -0,0 +1,10 @@ +--- +version: '1.0' +general: + condition: + type: boolean + default: true + mode_conteneur_actif: + mandatory: + type: variable + variable: _.condition diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/after.json b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/after.json new file mode 100644 index 000000000..5d5ce8188 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/after.json @@ -0,0 +1,10 @@ +{ + "rougail.general.condition": { + "owner": "default", + "value": true + }, + "rougail.general.mode_conteneur_actif": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/base.json b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/base.json new file mode 100644 index 000000000..4ec5f8013 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/base.json @@ -0,0 +1,4 @@ +{ + "rougail.general.condition": true, + "rougail.general.mode_conteneur_actif": null +} diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/before.json b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/before.json new file mode 100644 index 000000000..5d5ce8188 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/before.json @@ -0,0 +1,10 @@ +{ + "rougail.general.condition": { + "owner": "default", + "value": true + }, + "rougail.general.mode_conteneur_actif": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/mandatory.json b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/mandatory.json new file mode 100644 index 000000000..89fb354f2 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path_variable/makedict/mandatory.json @@ -0,0 +1 @@ +["rougail.general.mode_conteneur_actif"] \ No newline at end of file diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/tiramisu/base.py b/tests/dictionaries/10load_mandatory_relative_path_variable/tiramisu/base.py new file mode 100644 index 000000000..e104e3f0e --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path_variable/tiramisu/base.py @@ -0,0 +1,73 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_4 = StrOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", properties=frozenset({"standard", Calculation(func['variable_to_property'], Params((ParamValue("mandatory"), ParamOption(option_3))), help_function=func['variable_to_property'])})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, option_4], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/10load_mandatory_relative_path_variable/tiramisu/multi.py b/tests/dictionaries/10load_mandatory_relative_path_variable/tiramisu/multi.py new file mode 100644 index 000000000..360961111 --- /dev/null +++ b/tests/dictionaries/10load_mandatory_relative_path_variable/tiramisu/multi.py @@ -0,0 +1,79 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_5 = StrOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", properties=frozenset({"standard", Calculation(func['variable_to_property'], Params((ParamValue("mandatory"), ParamOption(option_4))), help_function=func['variable_to_property'])})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, option_5], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_9 = BoolOption(name="condition", doc="condition", default=True, properties=frozenset({"mandatory", "standard"})) +option_10 = StrOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", properties=frozenset({"standard", Calculation(func['variable_to_property'], Params((ParamValue("mandatory"), ParamOption(option_9))), help_function=func['variable_to_property'])})) +optiondescription_8 = OptionDescription(name="general", doc="general", children=[option_9, option_10], properties=frozenset({"standard"})) +optiondescription_7 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_8], properties=frozenset({"standard"})) +optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6]) diff --git a/tests/dictionaries/10load_param_relative/__init__.py b/tests/dictionaries/10load_param_relative/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/10load_param_relative/dictionaries/rougail/00-base.yml b/tests/dictionaries/10load_param_relative/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..2d5da8de3 --- /dev/null +++ b/tests/dictionaries/10load_param_relative/dictionaries/rougail/00-base.yml @@ -0,0 +1,18 @@ +--- +version: '1.0' +general: + variable: + relative: + disabled: + type: jinja + params: + variable: + type: variable + variable: _.variable + optional: true + jinja: | + {% if variable is not defined %} + variable is undefined + {% elif variable == "no" %} + variable is no + {% endif %} diff --git a/tests/dictionaries/10load_param_relative/makedict/after.json b/tests/dictionaries/10load_param_relative/makedict/after.json new file mode 100644 index 000000000..4228b1684 --- /dev/null +++ b/tests/dictionaries/10load_param_relative/makedict/after.json @@ -0,0 +1,10 @@ +{ + "rougail.general.variable": { + "owner": "default", + "value": null + }, + "rougail.general.relative": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10load_param_relative/makedict/base.json b/tests/dictionaries/10load_param_relative/makedict/base.json new file mode 100644 index 000000000..be4555270 --- /dev/null +++ b/tests/dictionaries/10load_param_relative/makedict/base.json @@ -0,0 +1,4 @@ +{ + "rougail.general.variable": null, + "rougail.general.relative": null +} diff --git a/tests/dictionaries/10load_param_relative/makedict/before.json b/tests/dictionaries/10load_param_relative/makedict/before.json new file mode 100644 index 000000000..4228b1684 --- /dev/null +++ b/tests/dictionaries/10load_param_relative/makedict/before.json @@ -0,0 +1,10 @@ +{ + "rougail.general.variable": { + "owner": "default", + "value": null + }, + "rougail.general.relative": { + "owner": "default", + "value": null + } +} diff --git a/tests/dictionaries/10load_param_relative/makedict/mandatory.json b/tests/dictionaries/10load_param_relative/makedict/mandatory.json new file mode 100644 index 000000000..f52204999 --- /dev/null +++ b/tests/dictionaries/10load_param_relative/makedict/mandatory.json @@ -0,0 +1 @@ +["rougail.general.variable", "rougail.general.relative"] \ No newline at end of file diff --git a/tests/dictionaries/10load_param_relative/tiramisu/base.py b/tests/dictionaries/10load_param_relative/tiramisu/base.py new file mode 100644 index 000000000..f712b214c --- /dev/null +++ b/tests/dictionaries/10load_param_relative/tiramisu/base.py @@ -0,0 +1,74 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['disabled_rougail.general.relative'] = "{% if variable is not defined %}\nvariable is undefined\n{% elif variable == \"no\" %}\nvariable is no\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = StrOption(name="variable", doc="variable", properties=frozenset({"basic", "mandatory"})) +option_4 = StrOption(name="relative", doc="relative", properties=frozenset({"basic", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_rougail.general.relative"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), 'variable': ParamOption(option_3)}), help_function=func['jinja_to_property_help'])})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, option_4], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"basic"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/10load_param_relative/tiramisu/multi.py b/tests/dictionaries/10load_param_relative/tiramisu/multi.py new file mode 100644 index 000000000..a5d0eeca0 --- /dev/null +++ b/tests/dictionaries/10load_param_relative/tiramisu/multi.py @@ -0,0 +1,81 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['disabled_1.rougail.general.relative'] = "{% if variable is not defined %}\nvariable is undefined\n{% elif variable == \"no\" %}\nvariable is no\n{% endif %}\n" +dict_env['disabled_2.rougail.general.relative'] = "{% if variable is not defined %}\nvariable is undefined\n{% elif variable == \"no\" %}\nvariable is no\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="variable", doc="variable", properties=frozenset({"basic", "mandatory"})) +option_5 = StrOption(name="relative", doc="relative", properties=frozenset({"basic", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_1.rougail.general.relative"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), 'variable': ParamOption(option_4)}), help_function=func['jinja_to_property_help'])})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, option_5], properties=frozenset({"basic"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"})) +option_9 = StrOption(name="variable", doc="variable", properties=frozenset({"basic", "mandatory"})) +option_10 = StrOption(name="relative", doc="relative", properties=frozenset({"basic", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_2.rougail.general.relative"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), 'variable': ParamOption(option_9)}), help_function=func['jinja_to_property_help'])})) +optiondescription_8 = OptionDescription(name="general", doc="general", children=[option_9, option_10], properties=frozenset({"basic"})) +optiondescription_7 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_8], properties=frozenset({"basic"})) +optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"basic"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6]) diff --git a/tests/dictionaries/10load_param_unknown_relative/__init__.py b/tests/dictionaries/10load_param_unknown_relative/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/10load_param_unknown_relative/dictionaries/rougail/00-base.yml b/tests/dictionaries/10load_param_unknown_relative/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..fbb44f540 --- /dev/null +++ b/tests/dictionaries/10load_param_unknown_relative/dictionaries/rougail/00-base.yml @@ -0,0 +1,17 @@ +--- +version: '1.0' +general: + relative: + disabled: + type: jinja + params: + variable: + type: variable + variable: _.variable + optional: true + jinja: | + {% if variable is not defined %} + variable is undefined + {% elif variable == "no" %} + variable is no + {% endif %} diff --git a/tests/dictionaries/10load_param_unknown_relative/makedict/after.json b/tests/dictionaries/10load_param_unknown_relative/makedict/after.json new file mode 100644 index 000000000..0967ef424 --- /dev/null +++ b/tests/dictionaries/10load_param_unknown_relative/makedict/after.json @@ -0,0 +1 @@ +{} diff --git a/tests/dictionaries/10load_param_unknown_relative/makedict/base.json b/tests/dictionaries/10load_param_unknown_relative/makedict/base.json new file mode 100644 index 000000000..0967ef424 --- /dev/null +++ b/tests/dictionaries/10load_param_unknown_relative/makedict/base.json @@ -0,0 +1 @@ +{} diff --git a/tests/dictionaries/10load_param_unknown_relative/makedict/before.json b/tests/dictionaries/10load_param_unknown_relative/makedict/before.json new file mode 100644 index 000000000..0967ef424 --- /dev/null +++ b/tests/dictionaries/10load_param_unknown_relative/makedict/before.json @@ -0,0 +1 @@ +{} diff --git a/tests/dictionaries/10load_param_unknown_relative/makedict/mandatory.json b/tests/dictionaries/10load_param_unknown_relative/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/10load_param_unknown_relative/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/10load_param_unknown_relative/tiramisu/base.py b/tests/dictionaries/10load_param_unknown_relative/tiramisu/base.py new file mode 100644 index 000000000..5da6e211a --- /dev/null +++ b/tests/dictionaries/10load_param_unknown_relative/tiramisu/base.py @@ -0,0 +1,73 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['disabled_rougail.general.relative'] = "{% if variable is not defined %}\nvariable is undefined\n{% elif variable == \"no\" %}\nvariable is no\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = StrOption(name="relative", doc="relative", properties=frozenset({"basic", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_rougail.general.relative"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False)}), help_function=func['jinja_to_property_help'])})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"basic"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/10load_param_unknown_relative/tiramisu/multi.py b/tests/dictionaries/10load_param_unknown_relative/tiramisu/multi.py new file mode 100644 index 000000000..1af00781a --- /dev/null +++ b/tests/dictionaries/10load_param_unknown_relative/tiramisu/multi.py @@ -0,0 +1,79 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['disabled_1.rougail.general.relative'] = "{% if variable is not defined %}\nvariable is undefined\n{% elif variable == \"no\" %}\nvariable is no\n{% endif %}\n" +dict_env['disabled_2.rougail.general.relative'] = "{% if variable is not defined %}\nvariable is undefined\n{% elif variable == \"no\" %}\nvariable is no\n{% endif %}\n" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="relative", doc="relative", properties=frozenset({"basic", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_1.rougail.general.relative"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False)}), help_function=func['jinja_to_property_help'])})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4], properties=frozenset({"basic"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"})) +option_8 = StrOption(name="relative", doc="relative", properties=frozenset({"basic", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_2.rougail.general.relative"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False)}), help_function=func['jinja_to_property_help'])})) +optiondescription_7 = OptionDescription(name="general", doc="general", children=[option_8], properties=frozenset({"basic"})) +optiondescription_6 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_7], 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]) diff --git a/tests/dictionaries/11valid_enum_relative_variable/__init__.py b/tests/dictionaries/11valid_enum_relative_variable/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/11valid_enum_relative_variable/dictionaries/rougail/00-base.yml b/tests/dictionaries/11valid_enum_relative_variable/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..94f06824d --- /dev/null +++ b/tests/dictionaries/11valid_enum_relative_variable/dictionaries/rougail/00-base.yml @@ -0,0 +1,15 @@ +--- +version: '1.0' +general: + mode_conteneur_actif: + type: choice + default: a + choices: + type: variable + variable: _.var + var: + multi: true + default: + - a + - b + - c diff --git a/tests/dictionaries/11valid_enum_relative_variable/makedict/after.json b/tests/dictionaries/11valid_enum_relative_variable/makedict/after.json new file mode 100644 index 000000000..da7c19731 --- /dev/null +++ b/tests/dictionaries/11valid_enum_relative_variable/makedict/after.json @@ -0,0 +1,14 @@ +{ + "rougail.general.mode_conteneur_actif": { + "owner": "default", + "value": "a" + }, + "rougail.general.var": { + "owner": "default", + "value": [ + "a", + "b", + "c" + ] + } +} diff --git a/tests/dictionaries/11valid_enum_relative_variable/makedict/base.json b/tests/dictionaries/11valid_enum_relative_variable/makedict/base.json new file mode 100644 index 000000000..0d2bcba8b --- /dev/null +++ b/tests/dictionaries/11valid_enum_relative_variable/makedict/base.json @@ -0,0 +1,8 @@ +{ + "rougail.general.mode_conteneur_actif": "a", + "rougail.general.var": [ + "a", + "b", + "c" + ] +} diff --git a/tests/dictionaries/11valid_enum_relative_variable/makedict/before.json b/tests/dictionaries/11valid_enum_relative_variable/makedict/before.json new file mode 100644 index 000000000..da7c19731 --- /dev/null +++ b/tests/dictionaries/11valid_enum_relative_variable/makedict/before.json @@ -0,0 +1,14 @@ +{ + "rougail.general.mode_conteneur_actif": { + "owner": "default", + "value": "a" + }, + "rougail.general.var": { + "owner": "default", + "value": [ + "a", + "b", + "c" + ] + } +} diff --git a/tests/dictionaries/11valid_enum_relative_variable/makedict/mandatory.json b/tests/dictionaries/11valid_enum_relative_variable/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/11valid_enum_relative_variable/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/11valid_enum_relative_variable/tiramisu/base.py b/tests/dictionaries/11valid_enum_relative_variable/tiramisu/base.py new file mode 100644 index 000000000..596bb5774 --- /dev/null +++ b/tests/dictionaries/11valid_enum_relative_variable/tiramisu/base.py @@ -0,0 +1,73 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="var", doc="var", multi=True, default=["a", "b", "c"], default_multi="a", properties=frozenset({"mandatory", "notempty", "standard"})) +option_3 = ChoiceOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", values=Calculation(func['calc_value'], Params((ParamOption(option_4)))), default="a", properties=frozenset({"mandatory", "standard"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, option_4], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/11valid_enum_relative_variable/tiramisu/multi.py b/tests/dictionaries/11valid_enum_relative_variable/tiramisu/multi.py new file mode 100644 index 000000000..25ef57d5f --- /dev/null +++ b/tests/dictionaries/11valid_enum_relative_variable/tiramisu/multi.py @@ -0,0 +1,79 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_5 = StrOption(name="var", doc="var", multi=True, default=["a", "b", "c"], default_multi="a", properties=frozenset({"mandatory", "notempty", "standard"})) +option_4 = ChoiceOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", values=Calculation(func['calc_value'], Params((ParamOption(option_5)))), default="a", properties=frozenset({"mandatory", "standard"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, option_5], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_10 = StrOption(name="var", doc="var", multi=True, default=["a", "b", "c"], default_multi="a", properties=frozenset({"mandatory", "notempty", "standard"})) +option_9 = ChoiceOption(name="mode_conteneur_actif", doc="mode_conteneur_actif", values=Calculation(func['calc_value'], Params((ParamOption(option_10)))), default="a", properties=frozenset({"mandatory", "standard"})) +optiondescription_8 = OptionDescription(name="general", doc="general", children=[option_9, option_10], properties=frozenset({"standard"})) +optiondescription_7 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_8], properties=frozenset({"standard"})) +optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6]) diff --git a/tests/dictionaries/12auto_func_variable_relative/__init__.py b/tests/dictionaries/12auto_func_variable_relative/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/12auto_func_variable_relative/dictionaries/rougail/00-base.yml b/tests/dictionaries/12auto_func_variable_relative/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..110b2092c --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative/dictionaries/rougail/00-base.yml @@ -0,0 +1,10 @@ +--- +version: '1.0' +general: + var: + hidden: true + default: + type: variable + variable: _.var2 + var2: + default: "no" diff --git a/tests/dictionaries/12auto_func_variable_relative/makedict/after.json b/tests/dictionaries/12auto_func_variable_relative/makedict/after.json new file mode 100644 index 000000000..9f3c72c6f --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative/makedict/after.json @@ -0,0 +1,10 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": "no" + }, + "rougail.general.var2": { + "owner": "default", + "value": "no" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative/makedict/base.json b/tests/dictionaries/12auto_func_variable_relative/makedict/base.json new file mode 100644 index 000000000..5f9b09720 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative/makedict/base.json @@ -0,0 +1,4 @@ +{ + "rougail.general.var": "no", + "rougail.general.var2": "no" +} diff --git a/tests/dictionaries/12auto_func_variable_relative/makedict/before.json b/tests/dictionaries/12auto_func_variable_relative/makedict/before.json new file mode 100644 index 000000000..9f3c72c6f --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative/makedict/before.json @@ -0,0 +1,10 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": "no" + }, + "rougail.general.var2": { + "owner": "default", + "value": "no" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative/makedict/mandatory.json b/tests/dictionaries/12auto_func_variable_relative/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/12auto_func_variable_relative/tiramisu/base.py b/tests/dictionaries/12auto_func_variable_relative/tiramisu/base.py new file mode 100644 index 000000000..c4c9e8ec8 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative/tiramisu/base.py @@ -0,0 +1,73 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="var2", doc="var2", default="no", properties=frozenset({"mandatory", "standard"})) +option_3 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_4)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, option_4], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/12auto_func_variable_relative/tiramisu/multi.py b/tests/dictionaries/12auto_func_variable_relative/tiramisu/multi.py new file mode 100644 index 000000000..b085eafcf --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative/tiramisu/multi.py @@ -0,0 +1,79 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_5 = StrOption(name="var2", doc="var2", default="no", properties=frozenset({"mandatory", "standard"})) +option_4 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_5)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, option_5], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_10 = StrOption(name="var2", doc="var2", default="no", properties=frozenset({"mandatory", "standard"})) +option_9 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_10)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_8 = OptionDescription(name="general", doc="general", children=[option_9, option_10], properties=frozenset({"standard"})) +optiondescription_7 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_8], properties=frozenset({"standard"})) +optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6]) diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/__init__.py b/tests/dictionaries/12auto_func_variable_relative_multi/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/dictionaries/rougail/00-base.yml b/tests/dictionaries/12auto_func_variable_relative_multi/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..af78c42ea --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_multi/dictionaries/rougail/00-base.yml @@ -0,0 +1,15 @@ +--- +version: '1.0' +general: + var: + hidden: true + multi: true + default: + - type: variable + variable: _.var2 + - type: variable + variable: _.var3 + var2: + default: "no" + var3: + default: "yes" diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/makedict/after.json b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/after.json new file mode 100644 index 000000000..28cb99a59 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/after.json @@ -0,0 +1,17 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": [ + "no", + "yes" + ] + }, + "rougail.general.var2": { + "owner": "default", + "value": "no" + }, + "rougail.general.var3": { + "owner": "default", + "value": "yes" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/makedict/base.json b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/base.json new file mode 100644 index 000000000..cb06d9ca1 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/base.json @@ -0,0 +1,8 @@ +{ + "rougail.general.var": [ + "no", + "yes" + ], + "rougail.general.var2": "no", + "rougail.general.var3": "yes" +} diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/makedict/before.json b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/before.json new file mode 100644 index 000000000..28cb99a59 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/before.json @@ -0,0 +1,17 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": [ + "no", + "yes" + ] + }, + "rougail.general.var2": { + "owner": "default", + "value": "no" + }, + "rougail.general.var3": { + "owner": "default", + "value": "yes" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/makedict/mandatory.json b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_multi/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/tiramisu/base.py b/tests/dictionaries/12auto_func_variable_relative_multi/tiramisu/base.py new file mode 100644 index 000000000..9e65e5bd6 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_multi/tiramisu/base.py @@ -0,0 +1,74 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="var2", doc="var2", default="no", properties=frozenset({"mandatory", "standard"})) +option_5 = StrOption(name="var3", doc="var3", default="yes", properties=frozenset({"mandatory", "standard"})) +option_3 = StrOption(name="var", doc="var", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_4)))), Calculation(func['calc_value'], Params((ParamOption(option_5))))], default_multi=Calculation(func['calc_value'], Params((ParamOption(option_4)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "notempty", "standard"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, option_4, option_5], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/12auto_func_variable_relative_multi/tiramisu/multi.py b/tests/dictionaries/12auto_func_variable_relative_multi/tiramisu/multi.py new file mode 100644 index 000000000..8b3e26c7b --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_multi/tiramisu/multi.py @@ -0,0 +1,81 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_5 = StrOption(name="var2", doc="var2", default="no", properties=frozenset({"mandatory", "standard"})) +option_6 = StrOption(name="var3", doc="var3", default="yes", properties=frozenset({"mandatory", "standard"})) +option_4 = StrOption(name="var", doc="var", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_5)))), Calculation(func['calc_value'], Params((ParamOption(option_6))))], default_multi=Calculation(func['calc_value'], Params((ParamOption(option_5)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "notempty", "standard"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, option_5, option_6], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_11 = StrOption(name="var2", doc="var2", default="no", properties=frozenset({"mandatory", "standard"})) +option_12 = StrOption(name="var3", doc="var3", default="yes", properties=frozenset({"mandatory", "standard"})) +option_10 = StrOption(name="var", doc="var", multi=True, default=[Calculation(func['calc_value'], Params((ParamOption(option_11)))), Calculation(func['calc_value'], Params((ParamOption(option_12))))], default_multi=Calculation(func['calc_value'], Params((ParamOption(option_11)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "notempty", "standard"})) +optiondescription_9 = OptionDescription(name="general", doc="general", children=[option_10, option_11, option_12], properties=frozenset({"standard"})) +optiondescription_8 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_9], properties=frozenset({"standard"})) +optiondescription_7 = OptionDescription(name="2", doc="2", children=[optiondescription_8], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_7]) diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/__init__.py b/tests/dictionaries/12auto_func_variable_relative_parent/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/dictionaries/rougail/00-base.yml b/tests/dictionaries/12auto_func_variable_relative_parent/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..e77bed902 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent/dictionaries/rougail/00-base.yml @@ -0,0 +1,11 @@ +--- +version: '1.0' +general: + var: + default: "no" + fam1: + var: + hidden: true + default: + type: variable + variable: __.var diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/makedict/after.json b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/after.json new file mode 100644 index 000000000..ccae5c65d --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/after.json @@ -0,0 +1,10 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": "no" + }, + "rougail.general.fam1.var": { + "owner": "default", + "value": "no" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/makedict/base.json b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/base.json new file mode 100644 index 000000000..8a97cc30c --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/base.json @@ -0,0 +1,4 @@ +{ + "rougail.general.var": "no", + "rougail.general.fam1.var": "no" +} diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/makedict/before.json b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/before.json new file mode 100644 index 000000000..ccae5c65d --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/before.json @@ -0,0 +1,10 @@ +{ + "rougail.general.var": { + "owner": "default", + "value": "no" + }, + "rougail.general.fam1.var": { + "owner": "default", + "value": "no" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/makedict/mandatory.json b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/tiramisu/base.py b/tests/dictionaries/12auto_func_variable_relative_parent/tiramisu/base.py new file mode 100644 index 000000000..a7aea7c3b --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent/tiramisu/base.py @@ -0,0 +1,74 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = StrOption(name="var", doc="var", default="no", properties=frozenset({"mandatory", "standard"})) +option_5 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_3)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_4 = OptionDescription(name="fam1", doc="fam1", children=[option_5], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, optiondescription_4], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/12auto_func_variable_relative_parent/tiramisu/multi.py b/tests/dictionaries/12auto_func_variable_relative_parent/tiramisu/multi.py new file mode 100644 index 000000000..4fd4cc97b --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent/tiramisu/multi.py @@ -0,0 +1,81 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="var", doc="var", default="no", properties=frozenset({"mandatory", "standard"})) +option_6 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_4)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_5 = OptionDescription(name="fam1", doc="fam1", children=[option_6], properties=frozenset({"standard"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, optiondescription_5], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_10 = StrOption(name="var", doc="var", default="no", properties=frozenset({"mandatory", "standard"})) +option_12 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_10)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_11 = OptionDescription(name="fam1", doc="fam1", children=[option_12], properties=frozenset({"standard"})) +optiondescription_9 = OptionDescription(name="general", doc="general", children=[option_10, optiondescription_11], properties=frozenset({"standard"})) +optiondescription_8 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_9], properties=frozenset({"standard"})) +optiondescription_7 = OptionDescription(name="2", doc="2", children=[optiondescription_8], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_7]) diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/__init__.py b/tests/dictionaries/12auto_func_variable_relative_parent_2/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/dictionaries/rougail/00-base.yml b/tests/dictionaries/12auto_func_variable_relative_parent_2/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..054caa090 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent_2/dictionaries/rougail/00-base.yml @@ -0,0 +1,12 @@ +--- +version: '1.0' +general: + fam2: + var: + default: "no" + fam1: + var: + hidden: true + default: + type: variable + variable: __.fam2.var diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/after.json b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/after.json new file mode 100644 index 000000000..373f0e974 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/after.json @@ -0,0 +1,10 @@ +{ + "rougail.general.fam2.var": { + "owner": "default", + "value": "no" + }, + "rougail.general.fam1.var": { + "owner": "default", + "value": "no" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/base.json b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/base.json new file mode 100644 index 000000000..872412059 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/base.json @@ -0,0 +1,4 @@ +{ + "rougail.general.fam2.var": "no", + "rougail.general.fam1.var": "no" +} diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/before.json b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/before.json new file mode 100644 index 000000000..373f0e974 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/before.json @@ -0,0 +1,10 @@ +{ + "rougail.general.fam2.var": { + "owner": "default", + "value": "no" + }, + "rougail.general.fam1.var": { + "owner": "default", + "value": "no" + } +} diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/mandatory.json b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent_2/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/tiramisu/base.py b/tests/dictionaries/12auto_func_variable_relative_parent_2/tiramisu/base.py new file mode 100644 index 000000000..bd9493d14 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent_2/tiramisu/base.py @@ -0,0 +1,75 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="var", doc="var", default="no", properties=frozenset({"mandatory", "standard"})) +optiondescription_3 = OptionDescription(name="fam2", doc="fam2", children=[option_4], properties=frozenset({"standard"})) +option_6 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_4)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_5 = OptionDescription(name="fam1", doc="fam1", children=[option_6], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[optiondescription_3, optiondescription_5], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/12auto_func_variable_relative_parent_2/tiramisu/multi.py b/tests/dictionaries/12auto_func_variable_relative_parent_2/tiramisu/multi.py new file mode 100644 index 000000000..d363c6e76 --- /dev/null +++ b/tests/dictionaries/12auto_func_variable_relative_parent_2/tiramisu/multi.py @@ -0,0 +1,83 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_5 = StrOption(name="var", doc="var", default="no", properties=frozenset({"mandatory", "standard"})) +optiondescription_4 = OptionDescription(name="fam2", doc="fam2", children=[option_5], properties=frozenset({"standard"})) +option_7 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_5)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_6 = OptionDescription(name="fam1", doc="fam1", children=[option_7], properties=frozenset({"standard"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[optiondescription_4, optiondescription_6], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_12 = StrOption(name="var", doc="var", default="no", properties=frozenset({"mandatory", "standard"})) +optiondescription_11 = OptionDescription(name="fam2", doc="fam2", children=[option_12], properties=frozenset({"standard"})) +option_14 = StrOption(name="var", doc="var", default=Calculation(func['calc_value'], Params((ParamOption(option_12)))), properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "standard"})) +optiondescription_13 = OptionDescription(name="fam1", doc="fam1", children=[option_14], properties=frozenset({"standard"})) +optiondescription_10 = OptionDescription(name="general", doc="general", children=[optiondescription_11, optiondescription_13], properties=frozenset({"standard"})) +optiondescription_9 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_10], properties=frozenset({"standard"})) +optiondescription_8 = OptionDescription(name="2", doc="2", children=[optiondescription_9], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_8]) diff --git a/tests/dictionaries/13fill_option_information_relative_path/__init__.py b/tests/dictionaries/13fill_option_information_relative_path/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/13fill_option_information_relative_path/dictionaries/rougail/00-base.yml b/tests/dictionaries/13fill_option_information_relative_path/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..8635fb109 --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/dictionaries/rougail/00-base.yml @@ -0,0 +1,14 @@ +--- +version: '1.0' +general: + variable: + variable2: + default: + type: jinja + jinja: '{{ information }}' + params: + information: + type: information + information: test_information + variable: _.variable + mandatory: false diff --git a/tests/dictionaries/13fill_option_information_relative_path/informations.json b/tests/dictionaries/13fill_option_information_relative_path/informations.json new file mode 100644 index 000000000..69510fc75 --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/informations.json @@ -0,0 +1 @@ +{"rougail.general.variable": "value"} diff --git a/tests/dictionaries/13fill_option_information_relative_path/makedict/after.json b/tests/dictionaries/13fill_option_information_relative_path/makedict/after.json new file mode 100644 index 000000000..df1f270dd --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/makedict/after.json @@ -0,0 +1,10 @@ +{ + "rougail.general.variable": { + "owner": "default", + "value": null + }, + "rougail.general.variable2": { + "owner": "default", + "value": "value" + } +} diff --git a/tests/dictionaries/13fill_option_information_relative_path/makedict/base.json b/tests/dictionaries/13fill_option_information_relative_path/makedict/base.json new file mode 100644 index 000000000..44136fdd8 --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/makedict/base.json @@ -0,0 +1,4 @@ +{ + "rougail.general.variable": null, + "rougail.general.variable2": "value" +} diff --git a/tests/dictionaries/13fill_option_information_relative_path/makedict/before.json b/tests/dictionaries/13fill_option_information_relative_path/makedict/before.json new file mode 100644 index 000000000..df1f270dd --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/makedict/before.json @@ -0,0 +1,10 @@ +{ + "rougail.general.variable": { + "owner": "default", + "value": null + }, + "rougail.general.variable2": { + "owner": "default", + "value": "value" + } +} diff --git a/tests/dictionaries/13fill_option_information_relative_path/makedict/mandatory.json b/tests/dictionaries/13fill_option_information_relative_path/makedict/mandatory.json new file mode 100644 index 000000000..f22b1c013 --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/makedict/mandatory.json @@ -0,0 +1 @@ +["rougail.general.variable"] \ No newline at end of file diff --git a/tests/dictionaries/13fill_option_information_relative_path/tiramisu/base.py b/tests/dictionaries/13fill_option_information_relative_path/tiramisu/base.py new file mode 100644 index 000000000..e2de6c7fa --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/tiramisu/base.py @@ -0,0 +1,74 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['default_rougail.general.variable2'] = "{{ information }}" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = StrOption(name="variable", doc="variable", properties=frozenset({"basic", "mandatory"})) +option_4 = StrOption(name="variable2", doc="variable2", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_rougail.general.variable2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), 'information': ParamInformation("test_information", None, option=option_3)})), properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3, option_4], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2], properties=frozenset({"basic"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/13fill_option_information_relative_path/tiramisu/multi.py b/tests/dictionaries/13fill_option_information_relative_path/tiramisu/multi.py new file mode 100644 index 000000000..02ec65a51 --- /dev/null +++ b/tests/dictionaries/13fill_option_information_relative_path/tiramisu/multi.py @@ -0,0 +1,81 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +dict_env['default_1.rougail.general.variable2'] = "{{ information }}" +dict_env['default_2.rougail.general.variable2'] = "{{ information }}" +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="variable", doc="variable", properties=frozenset({"basic", "mandatory"})) +option_5 = StrOption(name="variable2", doc="variable2", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_1.rougail.general.variable2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), 'information': ParamInformation("test_information", None, option=option_4)})), properties=frozenset({"standard"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4, option_5], properties=frozenset({"basic"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3], properties=frozenset({"basic"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"})) +option_9 = StrOption(name="variable", doc="variable", properties=frozenset({"basic", "mandatory"})) +option_10 = StrOption(name="variable2", doc="variable2", default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_2.rougail.general.variable2"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), 'information': ParamInformation("test_information", None, option=option_9)})), properties=frozenset({"standard"})) +optiondescription_8 = OptionDescription(name="general", doc="general", children=[option_9, option_10], properties=frozenset({"basic"})) +optiondescription_7 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_8], properties=frozenset({"basic"})) +optiondescription_6 = OptionDescription(name="2", doc="2", children=[optiondescription_7], properties=frozenset({"basic"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_6]) diff --git a/tests/dictionaries/20family_dynamic_inside/__init__.py b/tests/dictionaries/20family_dynamic_inside/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/dictionaries/20family_dynamic_inside/dictionaries/rougail/00-base.yml b/tests/dictionaries/20family_dynamic_inside/dictionaries/rougail/00-base.yml new file mode 100644 index 000000000..f9ec5f7e2 --- /dev/null +++ b/tests/dictionaries/20family_dynamic_inside/dictionaries/rougail/00-base.yml @@ -0,0 +1,22 @@ +--- +version: '1.0' +general: + varname: + multi: true + default: + - val1 + - val2 +"{{ suffix }}_dyn": + type: dynamic + variable: rougail.general.varname + var1: + default: + type: suffix + var2: + default: + type: variable + variable: rougail.{{ suffix }}_dyn.var1 + var3: + default: + type: variable + variable: _.var1 diff --git a/tests/dictionaries/20family_dynamic_inside/makedict/after.json b/tests/dictionaries/20family_dynamic_inside/makedict/after.json new file mode 100644 index 000000000..ce3a3ca09 --- /dev/null +++ b/tests/dictionaries/20family_dynamic_inside/makedict/after.json @@ -0,0 +1,33 @@ +{ + "rougail.general.varname": { + "owner": "default", + "value": [ + "val1", + "val2" + ] + }, + "rougail.val1_dyn.var1": { + "owner": "default", + "value": "val1" + }, + "rougail.val1_dyn.var2": { + "owner": "default", + "value": "val1" + }, + "rougail.val1_dyn.var3": { + "owner": "default", + "value": "val1" + }, + "rougail.val2_dyn.var1": { + "owner": "default", + "value": "val2" + }, + "rougail.val2_dyn.var2": { + "owner": "default", + "value": "val2" + }, + "rougail.val2_dyn.var3": { + "owner": "default", + "value": "val2" + } +} diff --git a/tests/dictionaries/20family_dynamic_inside/makedict/base.json b/tests/dictionaries/20family_dynamic_inside/makedict/base.json new file mode 100644 index 000000000..efa5b9474 --- /dev/null +++ b/tests/dictionaries/20family_dynamic_inside/makedict/base.json @@ -0,0 +1,12 @@ +{ + "rougail.general.varname": [ + "val1", + "val2" + ], + "rougail.val1_dyn.var1": "val1", + "rougail.val1_dyn.var2": "val1", + "rougail.val1_dyn.var3": "val1", + "rougail.val2_dyn.var1": "val2", + "rougail.val2_dyn.var2": "val2", + "rougail.val2_dyn.var3": "val2" +} diff --git a/tests/dictionaries/20family_dynamic_inside/makedict/before.json b/tests/dictionaries/20family_dynamic_inside/makedict/before.json new file mode 100644 index 000000000..ce3a3ca09 --- /dev/null +++ b/tests/dictionaries/20family_dynamic_inside/makedict/before.json @@ -0,0 +1,33 @@ +{ + "rougail.general.varname": { + "owner": "default", + "value": [ + "val1", + "val2" + ] + }, + "rougail.val1_dyn.var1": { + "owner": "default", + "value": "val1" + }, + "rougail.val1_dyn.var2": { + "owner": "default", + "value": "val1" + }, + "rougail.val1_dyn.var3": { + "owner": "default", + "value": "val1" + }, + "rougail.val2_dyn.var1": { + "owner": "default", + "value": "val2" + }, + "rougail.val2_dyn.var2": { + "owner": "default", + "value": "val2" + }, + "rougail.val2_dyn.var3": { + "owner": "default", + "value": "val2" + } +} diff --git a/tests/dictionaries/20family_dynamic_inside/makedict/mandatory.json b/tests/dictionaries/20family_dynamic_inside/makedict/mandatory.json new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/tests/dictionaries/20family_dynamic_inside/makedict/mandatory.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/tests/dictionaries/20family_dynamic_inside/tiramisu/base.py b/tests/dictionaries/20family_dynamic_inside/tiramisu/base.py new file mode 100644 index 000000000..03c03e143 --- /dev/null +++ b/tests/dictionaries/20family_dynamic_inside/tiramisu/base.py @@ -0,0 +1,77 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +from rougail.tiramisu import ConvertDynOptionDescription +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_3 = StrOption(name="varname", doc="varname", multi=True, default=["val1", "val2"], default_multi="val1", properties=frozenset({"mandatory", "notempty", "standard"})) +optiondescription_2 = OptionDescription(name="general", doc="general", children=[option_3], properties=frozenset({"standard"})) +option_5 = StrOption(name="var1", doc="var1", default=Calculation(func['calc_value'], Params((ParamSuffix()))), properties=frozenset({"mandatory", "standard"})) +option_6 = StrOption(name="var2", doc="var2", default=Calculation(func['calc_value'], Params((ParamOption(option_5)))), properties=frozenset({"mandatory", "standard"})) +option_7 = StrOption(name="var3", doc="var3", default=Calculation(func['calc_value'], Params((ParamOption(option_5)))), properties=frozenset({"mandatory", "standard"})) +optiondescription_4 = ConvertDynOptionDescription(name="{{ suffix }}_dyn", doc="{{ suffix }}_dyn", suffixes=Calculation(func['calc_value'], Params((ParamOption(option_3, notraisepropertyerror=True)))), children=[option_5, option_6, option_7], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_2, optiondescription_4], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1]) diff --git a/tests/dictionaries/20family_dynamic_inside/tiramisu/multi.py b/tests/dictionaries/20family_dynamic_inside/tiramisu/multi.py new file mode 100644 index 000000000..12a67568b --- /dev/null +++ b/tests/dictionaries/20family_dynamic_inside/tiramisu/multi.py @@ -0,0 +1,86 @@ +from tiramisu import * +from tiramisu.setting import ALLOWED_LEADER_PROPERTIES +ALLOWED_LEADER_PROPERTIES.add("basic") +ALLOWED_LEADER_PROPERTIES.add("standard") +ALLOWED_LEADER_PROPERTIES.add("advanced") +from importlib.machinery import SourceFileLoader as _SourceFileLoader +from importlib.util import spec_from_loader as _spec_from_loader, module_from_spec as _module_from_spec +global func +func = {'calc_value': calc_value} + +def _load_functions(path): + global _SourceFileLoader, _spec_from_loader, _module_from_spec, func + loader = _SourceFileLoader('func', path) + spec = _spec_from_loader(loader.name, loader) + func_ = _module_from_spec(spec) + loader.exec_module(func_) + for function in dir(func_): + if function.startswith('_'): + continue + func[function] = getattr(func_, function) +_load_functions('tests/dictionaries/../eosfunc/test.py') +from jinja2 import StrictUndefined, DictLoader +from jinja2.sandbox import SandboxedEnvironment +from rougail.annotator.variable import CONVERT_OPTION +from tiramisu.error import ValueWarning +def jinja_to_function(__internal_jinja, __internal_type, __internal_multi, **kwargs): + global ENV, CONVERT_OPTION + kw = {} + for key, value in kwargs.items(): + if '.' in key: + c_kw = kw + path, var = key.rsplit('.', 1) + for subkey in path.split('.'): + c_kw = c_kw.setdefault(subkey, {}) + c_kw[var] = value + else: + kw[key] = value + values = ENV.get_template(__internal_jinja).render(kw, **func).strip() + convert = CONVERT_OPTION[__internal_type].get('func', str) + if __internal_multi: + return [convert(val) for val in values.split()] + values = convert(values) + return values if values != '' and values != 'None' else None +def variable_to_property(prop, value): + return prop if value else None +def jinja_to_property(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return func['variable_to_property'](prop, value is not None) +def jinja_to_property_help(prop, **kwargs): + value = func['jinja_to_function'](**kwargs) + return (prop, f'"{prop}" ({value})') +def valid_with_jinja(warnings_only=False, **kwargs): + global ValueWarning + value = func['jinja_to_function'](**kwargs) + if value: + if warnings_only: + raise ValueWarning(value) + else: + raise ValueError(value) +func['jinja_to_function'] = jinja_to_function +func['jinja_to_property'] = jinja_to_property +func['jinja_to_property_help'] = jinja_to_property_help +func['variable_to_property'] = variable_to_property +func['valid_with_jinja'] = valid_with_jinja +dict_env = {} +from rougail.tiramisu import ConvertDynOptionDescription +ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined) +ENV.filters = func +ENV.compile_templates('jinja_caches', zip=None) +option_4 = StrOption(name="varname", doc="varname", multi=True, default=["val1", "val2"], default_multi="val1", properties=frozenset({"mandatory", "notempty", "standard"})) +optiondescription_3 = OptionDescription(name="general", doc="general", children=[option_4], properties=frozenset({"standard"})) +option_6 = StrOption(name="var1", doc="var1", default=Calculation(func['calc_value'], Params((ParamSuffix()))), properties=frozenset({"mandatory", "standard"})) +option_7 = StrOption(name="var2", doc="var2", default=Calculation(func['calc_value'], Params((ParamOption(option_6)))), properties=frozenset({"mandatory", "standard"})) +option_8 = StrOption(name="var3", doc="var3", default=Calculation(func['calc_value'], Params((ParamOption(option_6)))), properties=frozenset({"mandatory", "standard"})) +optiondescription_5 = ConvertDynOptionDescription(name="{{ suffix }}_dyn", doc="{{ suffix }}_dyn", suffixes=Calculation(func['calc_value'], Params((ParamOption(option_4, notraisepropertyerror=True)))), children=[option_6, option_7, option_8], properties=frozenset({"standard"})) +optiondescription_2 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_3, optiondescription_5], properties=frozenset({"standard"})) +optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"})) +option_12 = StrOption(name="varname", doc="varname", multi=True, default=["val1", "val2"], default_multi="val1", properties=frozenset({"mandatory", "notempty", "standard"})) +optiondescription_11 = OptionDescription(name="general", doc="general", children=[option_12], properties=frozenset({"standard"})) +option_14 = StrOption(name="var1", doc="var1", default=Calculation(func['calc_value'], Params((ParamSuffix()))), properties=frozenset({"mandatory", "standard"})) +option_15 = StrOption(name="var2", doc="var2", default=Calculation(func['calc_value'], Params((ParamOption(option_14)))), properties=frozenset({"mandatory", "standard"})) +option_16 = StrOption(name="var3", doc="var3", default=Calculation(func['calc_value'], Params((ParamOption(option_14)))), properties=frozenset({"mandatory", "standard"})) +optiondescription_13 = ConvertDynOptionDescription(name="{{ suffix }}_dyn", doc="{{ suffix }}_dyn", suffixes=Calculation(func['calc_value'], Params((ParamOption(option_12, notraisepropertyerror=True)))), children=[option_14, option_15, option_16], properties=frozenset({"standard"})) +optiondescription_10 = OptionDescription(name="rougail", doc="rougail", children=[optiondescription_11, optiondescription_13], properties=frozenset({"standard"})) +optiondescription_9 = OptionDescription(name="2", doc="2", children=[optiondescription_10], properties=frozenset({"standard"})) +option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_9]) diff --git a/tests/dictionaries/20family_dynamic_variable_outside/dictionaries/rougail/00-base.yml b/tests/dictionaries/20family_dynamic_variable_outside/dictionaries/rougail/00-base.yml index 67d6e1134..08a76571b 100644 --- a/tests/dictionaries/20family_dynamic_variable_outside/dictionaries/rougail/00-base.yml +++ b/tests/dictionaries/20family_dynamic_variable_outside/dictionaries/rougail/00-base.yml @@ -3,8 +3,8 @@ version: '1.1' varname: multi: true default: - - val1 - - val2 + - val1 + - val2 my_dyn_family_: type: dynamic dynamic: