rougail-output-doc/src/rougail/output_doc/doc.py

"""
Silique (https://www.silique.fr)
Copyright (C) 2024-2025

This program is free software: you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by the
Free Software Foundation, either version 3 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 Lesser General Public License for more
details.

You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

from warnings import warn
from typing import Optional
from itertools import chain
from re import compile

from tiramisu import Calculation, groups
from tiramisu.error import ConfigError, display_list, PropertiesOptionError
from rougail.tiramisu import display_xmlfiles, normalize_family
from rougail.utils import undefined, get_properties_to_string, PROPERTY_ATTRIBUTE
from rougail.error import VariableCalculationDependencyError, RougailWarning

from .config import OutPuts
from .i18n import _
from .utils import DocTypes, dump, to_phrase, calc_path
from .example import Examples
from .changelog import Changelog


HIDDEN_PROPERTIES = [
    "hidden",
    "disabled",
]


class RougailOutputDoc(Examples, Changelog):
    """Rougail Output Doc:
    Generate documentation from rougail description files
    """

    def __init__(
        self,
        config: "Config",
        *,
        rougailconfig: "RougailConfig" = None,
        **kwarg,
    ):
        # Import here to avoid circular import
        from rougail.tiramisu import CONVERT_OPTION

        self.convert_option = CONVERT_OPTION
        if rougailconfig is None:
            from rougail import RougailConfig

            rougailconfig = RougailConfig
            if rougailconfig["step.output"] != "doc":
                rougailconfig["step.output"] = "doc"
        if rougailconfig["step.output"] != "doc":
            raise Exception("doc is not set as step.output")
        self.outputs = OutPuts().get()
        self.conf = config
        self.modes_level = rougailconfig["modes_level"]
        if self.modes_level:
            self.disabled_modes = rougailconfig["doc.disabled_modes"]
            if self.disabled_modes:
                self.conf.property.setdefault(
                    frozenset(self.disabled_modes), "read_write", "append"
                )
        else:
            self.disabled_modes = []
        self.conf.property.read_write()
        # self.conf.property.remove("cache")
        self.rougailconfig = rougailconfig
        self.informations = None
        try:
            groups.namespace
            self.support_namespace = True
        except AttributeError:
            self.support_namespace = False
        self.property_to_string = get_properties_to_string()
        self.formatter = None
        super().__init__()

    def run(self) -> str:
        """Print documentation in stdout"""
        self.load()
        self.load_formatter()
        return_string = ""
        contents = self.rougailconfig["doc.contents"]
        if "variables" in contents:
            return_string += self.formatter.run(self.informations)
        if "example" in contents:
            return_string += self.gen_doc_examples()
        if "changelog" in contents:
            return_string += self.gen_doc_changelog()
        return True, return_string

    def load_formatter(self) -> str:
        output_format = self.rougailconfig["doc.output_format"]
        self.formatter = self.outputs[output_format](self.rougailconfig)

    def print(self) -> None:
        ret, data = self.run()
        print(data)
        return ret

    def load(self):
        self.dynamic_paths = {}
        config = self.conf.unrestraint
        self.populate_dynamics(config=config)
        informations = self.parse_families(config)
        if informations is None:
            informations = {}
        self.informations = informations

    def populate_dynamics(self, *, config=None, reload=False):
        if config is None:
            config = self.conf.unrestraint
        self._populate_dynamics(config, reload)

    def _populate_dynamics(self, family, reload, uncalculated=False) -> None:
        def populate(child, uncalculated):
            if child.isoptiondescription():
                type_ = "family"
            else:
                type_ = "variable"
            if child.isdynamic():
                self.populate_dynamic(child, type_, reload, uncalculated)
            if child.isoptiondescription():
                self._populate_dynamics(child, reload, uncalculated)
        for child in family.list(uncalculated=uncalculated):
            populate(child, uncalculated)
        if not uncalculated:
            for child in family.list(uncalculated=True):
                if child.isdynamic() and child.path(uncalculated=True) not in self.dynamic_paths:
                    populate(family, uncalculated=True)

    def populate_dynamic(self, obj, type_, reload, uncalculated) -> None:
        path = obj.path(uncalculated=True)
        if path not in self.dynamic_paths:
            new_name = True
            description = obj.description(uncalculated=True)
            name = obj.name(uncalculated=True)
            self.dynamic_paths[path] = {
                "names": [],
                "identifiers": [],
                "path": path,
            }
            if not obj.information.get("forced_description", False):
                self.dynamic_paths[path]["description"] = self._convert_description(
                    description, type_, its_a_path=False
                )
            elif obj.isoptiondescription():
                self.dynamic_paths[path]["description"] = self._convert_description(
                    description, type_, its_a_path=True
                )
        if uncalculated:
            return
        dynamic_obj = self.dynamic_paths[path]
        if reload and obj.identifiers() in dynamic_obj["identifiers"]:
            return
        dynamic_obj["names"].append(obj.name())
        dynamic_obj["identifiers"].append(obj.identifiers())

    def parse_families(self, family) -> dict:
        informations = {}
        leader = None
        for child in family.list():
            if self.is_inaccessible_user_data(child):
                continue
            if child.type(only_self=True) == "symlink":
                continue
            if not child.isoptiondescription():
                leader = self.parse_variable(child, leader, informations)
            else:
                self.parse_family(child, informations)
        return informations

    def is_inaccessible_user_data(self, child):
        """If family is not accessible in read_write mode (to load user_data),
        do not comment this family
        """
        properties = child.property.get(uncalculated=True)
        for hidden_property in HIDDEN_PROPERTIES:
            if hidden_property in properties:
                return True

            calculation = child.information.get(f"{hidden_property}_calculation", None)
            if calculation and calculation.get("type") == "variable":
                variable_path, value, condition = calculation["value"]
                variable = self.conf.forcepermissive.option(variable_path)
                try:
                    variable.value.get()
                except AttributeError:
                    variable = None
                if variable and self.is_inaccessible_user_data(variable):
                    try:
                        variable_value = self._get_unmodified_default_value(variable)
                    except VariableCalculationDependencyError:
                        pass
                    else:
                        if (condition == "when" and value == variable_value) or (condition == "when_not" and value != variable_value):
                            return True
        if not child.isoptiondescription():
            for hidden_property in self.disabled_modes:
                if hidden_property in properties:
                    return True
        return False

    def parse_family(self, family, informations: dict, *, force_injection=False) -> None:
        path = family.path(uncalculated=True)
        name = family.name(uncalculated=True)
        sub_informations = self.parse_families(family)
        if not force_injection and not sub_informations:
            return
        #        if self.with_family:
        family_informations = self._populate_family(
            family,
            path,
        )
        if family_informations is not False:
            informations[name] = {
                "type": self._get_family_type(family),
                "informations": family_informations,
                "children": sub_informations,
            }

    def parse_variable(
        self,
        variable,
        leader: dict,
        informations: dict,
        *,
        only_one=False,
    ) -> Optional[dict]:
        path = variable.path(uncalculated=True)
        name = variable.name(uncalculated=True)
        potential_leader = None
        if variable.isdynamic():
            # information is already set
            potential_leader = self._parse_variable_dynamic(
                variable, leader, name, path, informations, only_one
            )
        elif variable.isfollower() and variable.index():
            self._parse_variable_follower_with_index(
                variable, leader, name, informations
            )
        else:
            potential_leader = self.parse_variable_normal(
                variable, leader, name, path, informations
            )
        if potential_leader:
            leader = potential_leader
        return leader

    def parse_variable_normal(
        self, variable, leader, name: str, path: str, informations: dict
    ) -> Optional[dict]:
        if variable.isdynamic():
            sub_informations = self.dynamic_paths[path]
        elif variable.isfollower() and path in informations:  #  variable.index():
            sub_informations = informations[name]
        else:
            sub_informations = {}
        if not self._populate_variable(
            variable,
            sub_informations,
        ):
            return None
        self._add_examples(variable, sub_informations, leader)
        informations[name] = sub_informations
        if variable.isleader():
            return sub_informations
        return None

    def _parse_variable_follower_with_index(
        self, variable, leader: dict, name: str, informations: dict
    ) -> None:
        if (variable.index() + 1) > len(leader["gen_examples"][-1]):
            return
        informations[name]["gen_examples"][-1][variable.index()] = self._get_example(
            variable, informations[name], None
        )

    def _parse_variable_dynamic(
        self, variable, leader, name, path, informations, only_one
    ) -> None:
#        if path not in self.dynamic_paths:
#            self.populate_dynamic(variable, path)
        dynamic_variable = self.dynamic_paths[path]
        if (not only_one or path in informations) and "type" in dynamic_variable:
            dynamic_variable["gen_examples"].append(
                self._get_example(variable, dynamic_variable, leader)
            )
            if variable.isleader():
                return dynamic_variable
            if not only_one:
                return None
        return self.parse_variable_normal(variable, leader, name, path, informations)

    def _get_family_type(self, family) -> str:
        if self.support_namespace and family.group_type() is groups.namespace:
            return "namespace"
        if family.isleadership():
            return "leadership"
        if family.isdynamic(only_self=True):
            return "dynamic"
        return "family"

    def _populate_family(
        self,
        family,
        path: str,
    ) -> dict:
        if family.isdynamic():
            informations = self.dynamic_paths[path]
        else:
            informations = {}
        if not self._populate(family, informations, "family"):
            return False
        if family.isleadership():
            informations.setdefault("help", []).append(
                _("This family contains lists of variable blocks")
            )
        if family.isdynamic(only_self=True):
            identifiers = self._to_string(family, "dynamic", do_not_raise=True)
            if identifiers is None:
                identifiers = family.identifiers(only_self=True)
            if not isinstance(identifiers, list):
                identifiers = [identifiers]
            informations["identifier"] = identifiers
            informations.setdefault("help", []).append(
                _("This family builds families dynamically")
            )
        return informations

    def _populate_variable(
        self,
        variable,
        informations: dict,
    ):
        informations["type"] = "variable"
        default = self._get_default(
            variable,
        )
        if default is not None:
            informations["default"] = {"name": _("Default"), "values": default}
        self._parse_type(
            variable,
            informations,
        )
        if not self._populate(variable, informations, "variable"):
            return False
        if variable.ismulti():
            multi = not variable.isfollower() or variable.issubmulti()
        else:
            multi = False
        if multi:
            informations["properties"].append(
                {
                    "type": "multiple",
                    "name": _("multiple"),
                }
            )
        examples = variable.information.get("examples", None)
        if examples is None:
            examples = variable.information.get("test", None)
        if examples is not None:
            if len(examples) == 1:
                name = _("Example")
                values = examples[0]
            else:
                name = _("Examples")
                values = list(examples)
            informations["examples"] = {
                "name": name,
                "values": values
            }
        tags = variable.information.get("tags", None)
        if tags:
            if len(tags) == 1:
                name = _("Tag")
                values = tags[0]
            else:
                name = _("Tags")
                values = list(tags)
            informations["tags"] = {
                "name": name,
                "values": values,
            }
        return True

    def _populate(
        self,
        child,
        informations: dict,
        type_: str,
    ):
        need_disabled, properties = self._parse_properties(child)
        if not need_disabled:
            return False
        name = child.name(uncalculated=True)
        if child.information.get("forced_description", False):
            if (
                not child.isoptiondescription()
                or not self.support_namespace
                or child.group_type() is not groups.namespace
            ):
                if (
                    child.isoptiondescription()
                    or not child.isfollower()
                    or not child.index()
                ):
                    warning = _('No attribute "description" for "{0}" in {1}').format(
                        child.path(uncalculated=True),
                        display_xmlfiles(child.information.get("ymlfiles")),
                    )
                    warn(
                        warning,
                        RougailWarning,
                    )
            if child.isoptiondescription():
                description = self._convert_description(
                    child.description(uncalculated=True), type_, its_a_path=True
                )
            else:
                description = None
        else:
            description = self._convert_description(
                child.description(uncalculated=True), type_, its_a_path=False
            )
        if not child.isdynamic():
            informations["path"] = child.path(uncalculated=True)
            informations["names"] = [child.name()]
            if description is not None:
                informations["description"] = description
        help_ = child.information.get("help", None)
        if help_:
            informations["help"] = [to_phrase(help_)]
        if "properties" in informations:
            informations["properties"].extend(properties)
        else:
            informations["properties"] = properties
        return True

    def _convert_description(self, description, type_, its_a_path=False):
        if not its_a_path:
            description = to_phrase(description, type_)
        return description

    def _add_examples(self, variable, informations: dict, leader) -> None:
        if not variable.index():
            example = self._get_example(variable, informations, leader)
            informations["gen_examples"] = [example]
        informations["mandatory_without_value"] = "mandatory" in variable.property.get(
            uncalculated=True
        ) and (
            not variable.information.get("default_value_makes_sense", True)
            or variable.value.get(uncalculated=True) in [None, []]
        )

    def _get_example(self, variable, informations: dict, leader):
        example = informations.get("examples", {}).get("values")
        if example is not None:
            if isinstance(example, tuple):
                example = list(example)
            for prop in informations["properties"]:
                if prop["type"] == "multiple":
                    if not isinstance(example, list):
                        example = [example]
                    break
            else:
                if isinstance(example, list):
                    index = variable.index()
                    if index is None or len(example) - 1 >= index:
                        index = 0
                    example = example[index]
        else:
            if variable.information.get("fake_default", False):
                default = None
            else:
                try:
                    default = variable.value.get()
                except ConfigError:
                    default = None
            if default not in [None, []]:
                example = default
            else:
                example = self.get_type_default_value(
                    variable, informations["properties"]
                )
        if leader is not None and variable.isfollower():
            example = [example] + [undefined] * (len(leader["gen_examples"][-1]) - 1)
        return example

    def get_type_default_value(self, variable, properties):
        example = self.convert_option.get(variable.information.get("type"), {}).get(
            "example", None
        )
        if example is None:
            example = "xxx"
        for prop in properties:
            if prop["type"] == "multiple":
                multi = True
                break
        else:
            multi = False
        if multi:
            example = [example]
        return example

    def _parse_type(
        self,
        child,
        informations,
    ):
        variable_type = child.information.get("type")
        doc_type = DocTypes.get(variable_type, {"params": {}})
        informations["properties"] = [
            {
                "type": "type",
                "name": doc_type.get("msg", variable_type),
            }
        ]
        # extra parameters for types
        option = child.get()
        validators = []
        for param, msg in doc_type["params"].items():
            value = option.impl_get_extra(f"_{param}")
            if value is None:
                value = option.impl_get_extra(param)
            if value is not None and value is not False:
                if isinstance(value, set):
                    value = list(value)
                if isinstance(value, list):
                    value = display_list(value, add_quote=True)
                validators.append(msg.format(value))

        # get validation information from annotator
        for name in child.information.list():
            if not name.startswith("validators_calculation"):
                continue
            validators.extend(
                self._to_string(
                    child,
                    "validators",
                )
            )
            break
        if child.information.get("type") == "regexp":
            validators.append(
                _('text based with regular expressions "{0}"').format(child.pattern())
            )
        if validators:
            if len(validators) == 1:
                key = _("Validator")
                validators = validators[0]
            else:
                key = _("Validators")
            informations["validators"] = {"name": key, "values": validators}
        if child.information.get("type") == "choice":
            choices = self._to_string(child, "choice", do_not_raise=True)
            if choices is None:
                choices = child.value.list()
                for idx, val in enumerate(choices):
                    if isinstance(val, Calculation):
                        choices[idx] = self._to_string(child, "choice", f"_{idx}")
            informations["choices"] = {"name": _("Choices"), "values": choices}

    def _parse_properties(
        self,
        child,
    ):
        informations = []
        properties = child.property.get(uncalculated=True)
        for mode in self.modes_level:
            if mode not in properties:
                continue
            informations.append(
                {
                    "type": "mode",
                    "name": mode,
                }
            )
            break
        for prop, translated_prop in self.property_to_string:
            if prop in properties:
                prop_obj = {
                    "type": "property",
                    "name": translated_prop,
                }
            elif child.information.get(f"{prop}_calculation", False):
                annotation = self._to_string(child, prop)
                if annotation is None or isinstance(annotation, bool):
                    if annotation is None and prop in HIDDEN_PROPERTIES:
                        return False, {}
                    if not annotation:
                        continue
                    prop_obj = {
                        "type": "property",
                        "name": translated_prop,
                    }
                else:
                    prop_obj = {
                        "type": "property",
                        "name": translated_prop,
                        "annotation": annotation,
                    }
            else:
                # this property is not in the variable so, do not comment it
                continue
            informations.append(prop_obj)
        return True, informations

    def _get_default(
        self,
        variable,
    ):
        default = self._to_string(variable, "default", do_not_raise=True)
        if default is not None:
            if default == []:
                default = None
            return default
        if variable.information.get("default_value_makes_sense", True):
            default_ = variable.value.get(uncalculated=True)
            if not isinstance(default_, Calculation):
                default = default_
        if default == []:
            default = None
        return default

    def _to_string(
        self,
        child,
        prop,
        do_not_raise=False,
    ):
        calculation = child.information.get(f"{prop}_calculation", None)
        if not calculation:
            if do_not_raise:
                return None
            raise Exception(
                f'cannot find "{prop}_calculation" information, '
                "do you have declare doc has a plugins?"
            )
        if isinstance(calculation, list):
            values = []
            for cal in calculation:
                value = self._calculation_to_string(child, cal, prop, inside_list=True)
                if value is not None:
                    values.append(value)
            return values
        return self._calculation_to_string(child, calculation, prop)

    def _calculation_to_string(self, child, calculation, prop, inside_list=False):
        if "description" in calculation:
            values = calculation["description"]
#            if not values.endswith("."):
#                values += "."
            return values
        if "type" not in calculation:
            return calculation["value"]
        if calculation["type"] == "jinja":
            values = self._calculation_jinja_to_string(child, calculation, prop)
        elif calculation["type"] == "variable":
            values = self._calculation_variable_to_string(child, calculation, prop)
        elif calculation["type"] == "identifier":
            if prop in PROPERTY_ATTRIBUTE:
                values = calculation["value"]
            else:
                values = _("the value of the identifier")
        elif calculation["type"] == "information":
            values = calculation["value"]
        else:
            values = _("the value of the {0}").format(calculation["type"])
#        if not inside_list and isinstance(values, str) and not values.endswith("."):
#            values += "."
        return values

    def _calculation_jinja_to_string(self, child, calculation, prop):
        if calculation["value"] is not True:
            values = calculation["value"]
        else:
            values = _("depends on a calculation")
            if (
                child.isoptiondescription()
                or not child.isfollower()
                or not child.index()
            ):
                warning = _(
                    '"{0}" is a calculation for {1} but has no description in {2}'
                ).format(
                    prop,
                    child.path(),
                    display_xmlfiles(child.information.get("ymlfiles")),
                )
                warn(
                    warning,
                    RougailWarning,
                )
        return values

    def _calculation_variable_to_string(self, child, calculation, prop):
        if prop in PROPERTY_ATTRIBUTE:
            values = self._calculation_variable_to_string_known_property(child, calculation, prop)
        else:
            if calculation["optional"]:
                path = calculation["value"]
                if "{{ identifier }}" in path:
                    if path not in self.dynamic_paths:
                        return None
                else:
                    try:
                        self.conf.forcepermissive.option(path).get()
                    except AttributeError:
                        return None
            if not calculation["optional"]:
                true_msg = _('the value of the variable "{0}"')
            else:
                true_msg = _('the value of the variable "{0}" if it is defined')
            if "{{ identifier }}" in calculation["ori_path"]:
                values = []
                all_is_undocumented = False
                for cpath, description, identifiers in self.get_annotation_variable(calculation["value"], calculation["ori_path"]):
                    if cpath:
                        all_is_undocumented = False
                        path_obj = {
                                "path": cpath,
                            }
                        if identifiers:
                            path_obj["identifiers"] = identifiers
                        values.append({
                            "message": true_msg,
                            "path": path_obj,
                            "description": description,
                        })
                    else:
                        if all_is_undocumented is None:
                            all_is_undocumented = True
                        values.append(_("the value of an undocumented variable"))
                if all_is_undocumented:
                    if len(values) > 1:
                        values = _("the values of undocumented variables")
                    else:
                        values = values[0]
            else:
                # FIXME A MUTUALISER AUSSI
                variable_path = calculation["ori_path"]
                variable = self.conf.forcepermissive.option(variable_path)
                try:
                    isfollower = variable.isfollower()
                except AttributeError as err:
                    pass
                else:
                    if not isfollower and self.is_inaccessible_user_data(variable):
                        try:
                            uncalculated = variable.value.get(uncalculated=True)
                        except PropertiesOptionError:
                            true_msg = None
                        else:
                            if uncalculated and not isinstance(
                                uncalculated, Calculation
                            ):
                                if isinstance(uncalculated, list):
                                    true_msg = {
                                        "submessage": _(
                                            "(from an undocumented variable)"
                                        ),
                                        "values": uncalculated,
                                    }
                                else:
                                    if not isinstance(uncalculated, str):
                                        uncalculated = dump(uncalculated)
                                    true_msg = _(
                                        "{0} (from an undocumented variable)"
                                    ).format(uncalculated)
                            else:
                                true_msg = _("depends on an undocumented variable")
                if true_msg:
                    if isinstance(true_msg, dict):
                        values = true_msg
                    else:
                        try:
                            description = self._convert_description(self.conf.option(calculation["ori_path"]).description(uncalculated=True), "description", its_a_path=False)
                        except AttributeError:
                            description = calculation["ori_path"]
                        values = {
                            "message": true_msg,
                            "path": {
                                "path": calculation["ori_path"],
                            },
                            "description": description,
                        }
                else:
                    values = None
        return values

    def _calculation_variable_to_string_known_property(self, child, calculation, prop):
        variable_path, value, condition = calculation["value"]
        if isinstance(value, str):
            str_value = value
        else:
            str_value = dump(value)
        values = []
        if "{{ identifier }}" in calculation["ori_path"] or "{{ identifier }}" in variable_path:
            variables = self.get_annotation_variable(variable_path, calculation["ori_path"])
        else:
            option = self.conf.option(variable_path)
            try:
                is_inaccessible = self.is_inaccessible_user_data(option)
            except AttributeError as err:
                if err.code != "option-not-found":
                    raise err from err
                is_inaccessible = True
            if is_inaccessible:
                variables = [[None, None, None]]
            else:
                description = self._convert_description(option.description(uncalculated=True), "description", its_a_path=False)
                variables = [[variable_path, description, None]]
        for cpath, description, identifiers in variables:
            if not cpath:
                variable = self.conf.forcepermissive.option(variable_path)
                try:
                    variable_value = self._get_unmodified_default_value(variable)
                except PropertiesOptionError as err:
                    if calculation["propertyerror"]:
                        raise err from err
                    variable_value = value
                except VariableCalculationDependencyError:
                    values.append(_("depends on an undocumented variable"))
                    continue
                except AttributeError as err:
                    #                    if err.code != "option-not-found" or not calculation.get("optional", False):
                    #                        raise err from err
                    return calculation.get("default", False)
                if (
                    condition == "when"
                    and value == variable_value
                    or condition == "when_not"
                    and value != variable_value
                ):
                    if prop in HIDDEN_PROPERTIES:
                        return False
                    # always "prop"
                    return True
                # never "prop"
                return False
            else:
                if condition == "when_not":
                    if calculation["optional"]:
                        if not calculation["propertyerror"]:
                            msg = _(
                                'when the variable "{{0}}" is defined, accessible and hasn\'t the value "{0}"'
                            )
                        else:
                            msg = _(
                                'when the variable "{{0}}" is defined and hasn\'t the value "{0}"'
                            )
                    elif not calculation["propertyerror"]:
                        msg = _('when the variable "{{0}}" is accessible and hasn\'t the value "{0}"')
                    else:
                        msg = _('when the variable "{{0}}" hasn\'t the value "{0}"')
                else:
                    if calculation["optional"]:
                        if not calculation["propertyerror"]:
                            msg = _(
                                'when the variable "{{0}}" is defined, is accessible and has the value "{0}"'
                            )
                        else:
                            msg = _(
                                'when the variable "{{0}}" is defined and has the value "{0}"'
                            )
                    elif not calculation["propertyerror"]:
                        msg = _('when the variable "{{0}}" is accessible and has the value "{0}"')
                    else:
                        msg = _('when the variable "{{0}}" has the value "{0}"')
                path_obj = {
                        "path": variable_path,
                    }
                if identifiers:
                    path_obj["identifiers"] = identifiers

                values.append({
                    "message": msg.format(str_value),
                    "path": path_obj,
                    "description": description,
                })
        if len(values) == 1:
            return values[0]
        return values

    def get_annotation_variable(self, current_path, ori_path):
        if current_path == ori_path:
            regexp = None
        else:
            regexp = compile(
                "^"
                + ori_path.replace("{{ identifier }}", "(.*)")
                + "$"
            )
        information = self.dynamic_paths[current_path]
        path = information["path"]
        for identifiers in information["identifiers"]:
            cpath = calc_path(path, identifiers=identifiers)
            if regexp and not regexp.search(cpath):
                continue
            if self.is_inaccessible_user_data(self.conf.option(cpath)):
                yield None, None, None
            else:
                description = self._convert_description(self.conf.option(path).description(uncalculated=True), "description", its_a_path=False)
                if "{{ identifier }}" in path:
                    yield path, description, identifiers.copy()
                else:
                    yield path, description, None

    def _get_unmodified_default_value(self, child):
        calculation = child.information.get(f"default_calculation", None)
        if not calculation:
            return child.value.get()
        if calculation["type"] == "variable":
            variable = self.conf.forcepermissive.option(calculation["value"])
            if variable and self.is_inaccessible_user_data(variable):
                return self._get_unmodified_default_value(variable)
        raise VariableCalculationDependencyError()