tiramisu/tiramisu/error.py

# -*- coding: utf-8 -*-
# Copyright (C) 2012-2026 Team tiramisu (see AUTHORS for all contributors)
#
# 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/>.
# ____________________________________________________________
"user defined exceptions"
import weakref
from .i18n import _

from typing import Literal, Union, Optional


TiramisuErrorCode = Literal[
    "option-dynamic",
    "option-not-found",
    "property-frozen",
    "property-error",
    "property-mandatory",
    "leadership-group_type",
    "leadership-wrong_property",
    "leadership-force_default_on_freeze",
    "leadership-greater",
    "leadership-follower-greater",
    "leadership-follower-callback-list",
]


def display_list(
    lst,
    *,
    separator="and",
    add_quote=False,
) -> str():
    if not lst:
        return '""'
    if separator == "and":
        separator = _("and")
    elif separator == "or":
        separator = _("or")
    if isinstance(lst, tuple) or isinstance(lst, frozenset):
        lst = list(lst)
    if len(lst) == 1:
        ret = lst[0]
        if not isinstance(ret, str):
            ret = str(ret)
        if add_quote and not ret.startswith('"'):
            ret = '"{}"'.format(ret)
        return ret
    lst_ = []
    for l in lst:
        if not isinstance(l, str):
            l = str(l)
        lst_.append(_(l))
    lst__ = []
    for l in lst_:
        if add_quote and not l.startswith('"'):
            l = '"{}"'.format(l)
        lst__.append(l)
    lst__.sort()
    last = lst__[-1]
    return ", ".join(lst__[:-1]) + _(" {} ").format(separator) + "{}".format(last)


# Exceptions for an Option
class PropertiesOptionError(AttributeError):
    "attempt to access to an option with a property that is not allowed"

    def __init__(
        self,
        subconfig,
        proptype,
        settings,
        opt_type=None,
        name=None,
        help_properties=None,
    ):
        if opt_type:
            self._opt_type = opt_type
            self._name = name
        else:
            if subconfig.option.impl_is_optiondescription():
                self._opt_type = "optiondescription"
            else:
                self._opt_type = "option"
            self._name = subconfig.option.impl_get_display_name(
                subconfig, with_quote=True
            )
            self._orig_opt = None
        self.subconfig = subconfig
        self.proptype = proptype
        self.help_properties = help_properties
        self._settings = settings
        self.msg = None
        if not self.help_properties:
            self.help_properties = self.proptype
        properties = list(self.help_properties)
        if properties == ["frozen"]:
            self.code = "property-frozen"
        elif properties == ["mandatory"]:
            self.code = "property-mandatory"
        else:
            self.code = "property-error"
        super().__init__(None)

    def display_properties(self, force_property=False, add_quote=True):
        if force_property:
            properties = self.proptype
        else:
            properties = self.help_properties
        return display_list(list(properties), add_quote=add_quote)

    def __str__(self):
        # this part is a bit slow, so only execute when display
        if self.msg is not None:
            return self.msg
        if self._settings is None:
            return "error"
        arguments = [self._opt_type]
        if self._orig_opt:
            arguments.append(
                self._orig_opt.impl_get_display_name(subconfig, with_quote=True)
            )
        arguments.append(self._name)
        index = self.subconfig.index
        if index is not None:
            arguments.append(index)
        if self.code == "property-frozen":
            if index is not None:
                if self._orig_opt:
                    msg = _(
                        'cannot modify the {0} {1} at index "{2}" because {3} is frozen'
                    )
                else:
                    msg = _(
                        'cannot modify the {0} {1} at index "{2}" because is frozen'
                    )
            else:
                if self._orig_opt:
                    msg = _("cannot modify the {0} {1} because {2} is frozen")
                else:
                    msg = _("cannot modify the {0} {1} because is frozen")
        elif self.code == "property-mandatory":
            if index is not None:
                if self._orig_opt:
                    msg = _(
                        'cannot access to {0} {1} at index "{2}" because {3} hasn\'t value'
                    )
                else:
                    msg = _('{0} {1} at index "{2}" is mandatory but hasn\'t value')
            else:
                if self._orig_opt:
                    msg = _("cannot access to {0} {1} because {2} hasn't value")
                else:
                    msg = _("{0} {1} is mandatory but hasn't value")
        else:
            if index is not None:
                if self._orig_opt:
                    msg = _(
                        'cannot access to {0} {1} at index "{2}" because {3} has {4} {5}'
                    )
                else:
                    msg = _(
                        'cannot access to {0} {1} at index "{2}" because has {3} {4}'
                    )
            else:
                if self._orig_opt:
                    msg = _("cannot access to {0} {1} because {2} has {3} {4}")
                else:
                    msg = _("cannot access to {0} {1} because has {2} {3}")
            only_one = len(self.help_properties) == 1
            if only_one:
                arguments.append(_("property"))
            else:
                arguments.append(_("properties"))
            arguments.append(self.display_properties())
        self.msg = msg.format(*arguments)
        del self._opt_type, self._name
        del self._settings, self._orig_opt
        return self.msg


class AttributeOptionError(AttributeError):
    def __init__(self, path: str, code: TiramisuErrorCode) -> None:
        self.path = path
        self.code = code

    def __str__(self) -> str:
        if self.code == "option-dynamic":
            return _('cannot access to "{0}" it\'s a dynamic option').format(self.path)
        return _('"{0}" is not an option').format(self.path)


# ____________________________________________________________
# Exceptions for a Config
class ConfigError(Exception):
    """attempt to change an option's owner without a value
    or in case of `_descr` is None
    or if a calculation cannot be carried out"""

    def __init__(
        self,
        exp,
        *,
        prefix: Optional[str] = None,
        subconfig: Optional["Subconfig"]=None,
    ):
        super().__init__(exp)
        self.err_msg = exp
        self.subconfig = subconfig
        self.prefix = prefix

    def __str__(self):
        msg = self.prefix
        if msg:
            msg += ", {}".format(self.err_msg)
        else:
            msg = self.err_msg
        return msg


class ConflictError(Exception):
    "duplicate options are present in a single config"
    pass


# ____________________________________________________________
# miscellaneous exceptions
class LeadershipError(Exception):
    def __init__(
        self,
        subconfig: Union[str, "SubConfig"],
        code,
        *,
        prop=None,
        index=None,
        length=None,
        callback=None,
        args=None,
        kwargs=None,
        ret=None,
    ):
        if isinstance(subconfig, str):
            self.path = self.display_name = subconfig
        else:
            self.path = subconfig.path
            option = subconfig.option
            self.display_name = option.impl_get_display_name(subconfig, with_quote=True)
        self.code = code
        if prop is not None:
            self.prop = prop
        if index is not None:
            self.index = index
        if length is not None:
            self.length = length
        if callback is not None:
            self.callback = callback
        if args is not None:
            self.args = args
        if kwargs is not None:
            self.kwargs = kwargs
        if ret is not None:
            self.ret = ret

    def __str__(self):
        if self.code == "leadership-group_type":
            return _('cannot set "group_type" attribute for the Leadership {0}').format(
                self.display_name
            )
        if self.code == "leadership-wrong_property":
            return _('the leader {0} cannot have "{1}" property').format(
                self.display_name, self.prop
            )
        if self.code == "leadership-force_default_on_freeze":
            return _(
                'the leader {0} cannot have "force_default_on_freeze" or "force_metaconfig_on_freeze" property without "frozen"'
            ).format(self.display_name)
        if self.code == "leadership-reduce":
            return _("cannot reduce length of the leader {0}").format(self.display_name)
        if self.code == "leadership-greater":
            return _(
                'index "{0}" is greater than the leadership length "{1}" for option {2}'
            ).format(self.index, self.length, self.display_name)
        if self.code == "leadership-follower-greater":
            return _(
                "the follower option {0} has greater length ({1}) than the leader length ({2})"
            ).format(self.display_name, self.index, self.length)
        if self.code == "leadership-follower-callback-list":
            if self.args or self.kwargs:
                return _(
                    'the "{0}" function with positional arguments "{1}" and keyword arguments "{2}" must not return a list ("{3}") for the follower option {4}'
                ).format(
                    self.callback, self.args, self.kwargs, self.ret, self.display_name
                )
            return _(
                'the "{0}" function must not return a list ("{1}") for the follower option {2}'
            ).format(self.callback, self.ret, self.display_name)


class ConstError(TypeError):
    "no uniq value in _NameSpace"
    pass


class _CommonError:
    def __init__(self, subconfig, val, display_type, opt, err_msg, index):
        self.val = val
        self.display_type = display_type
        self.opt = weakref.ref(opt)
        self.name = opt.impl_get_display_name(subconfig, with_quote=True)
        if subconfig:
            self.path = subconfig.path
        self.err_msg = err_msg
        self.index = index
        super().__init__(self.err_msg)

    def __str__(self):
        try:
            msg = self.prefix
        except AttributeError:
            self.prefix = self.tmpl.format(
                self.val, _(self.display_type), self.name, self.index
            )
            msg = self.prefix
        if self.err_msg:
            if msg:
                msg += ", {}".format(self.err_msg)
            else:
                msg = self.err_msg
        if not msg:
            msg = _("invalid value")
        return msg


class ValueWarning(_CommonError, UserWarning):
    tmpl = None

    def __init__(self, **kwargs):
        if ValueWarning.tmpl is None:
            if kwargs.get("index") is None:
                ValueWarning.tmpl = _(
                    'attention, "{0}" could be an invalid {1} for {2}'
                )
            else:
                ValueWarning.tmpl = _(
                    'attention, "{0}" could be an invalid {1} for {2} at index "{3}"'
                )
        if list(kwargs) == ["msg"]:
            self.msg = kwargs["msg"]
        else:
            super().__init__(**kwargs)
            self.msg = None

    def __str__(self):
        if self.msg is None:
            return super().__str__()
        return self.msg


class ValueOptionError(_CommonError, ValueError):
    tmpl = None

    def __init__(self, **kwargs):
        if ValueOptionError.tmpl is None:
            opt = kwargs.get("opt")
            if opt and opt._do_not_display_value_in_error:
                if kwargs.get("index") is None:
                    self.tmpl = _("{2} has an invalid {1}")
                else:
                    self.tmpl = _('{2} at index "{3}" has an invalid {1}')
            else:
                if kwargs.get("index") is None:
                    self.tmpl = _('"{0}" is an invalid {1} for {2}')
                else:
                    self.tmpl = _('"{0}" is an invalid {1} for {2} at index "{3}"')
        super().__init__(**kwargs)


class ValueErrorWarning(ValueWarning):
    tmpl = None

    def __init__(self, *args, **kwargs):
        if ValueErrorWarning.tmpl is None:
            ValueErrorWarning.tmpl = _('"{0}" is an invalid {1} for {2}')
        super().__init__(*args, **kwargs)


class CancelParam(Exception):
    def __init__(self, origin_path, current_path):
        super().__init__()
        self.origin_path = origin_path
        self.current_path = current_path

    def __ne__(self, value):
        return value is None or value == ""

    def __eq__(self, value):
        return value is None or value == ""

    def __bool__(self):
        return False


class ValueErrorIndexes(ValueError):
    def __init__(self, msg, indexes):
        super().__init__(msg)
        self.indexes = indexes


class Errors:
    @staticmethod
    def raise_carry_out_calculation_error(
        subconfig, message, original_error, option=None, extra_keys=[]
    ):
        if option is None:
            option = subconfig.option
        display_name = option.impl_get_display_name(subconfig, with_quote=True)
        if original_error:
            raise ConfigError(
                message.format(display_name, original_error, *extra_keys), subconfig=subconfig,
            ) from original_error
        raise ConfigError(message.format(display_name, extra_keys), subconfig=subconfig)


errors = Errors()