error ¶

def __call__(
    self,
    message: SupportsString | None | MissingT = MISSING,
    func: FuncExcept | None | MissingT = MISSING,
    reason: SupportsString | FuncExcept | None | MissingT = MISSING,
    **kwargs: Any,
) -> Self:
    """
    Copy an existing exception with defaults and instantiate a new one.

    Args:
        message: Message of the error.
        func: Function this exception was raised from.
        reason: Reason of the exception. For example, an optional parameter.
    """
    from copy import deepcopy

    err = deepcopy(self)

    if message is not MISSING:
        err.message = message

    if func is not MISSING:
        err.func = func

    if reason is not MISSING:
        err.reason = reason

    err.kwargs |= kwargs

    return err

def add_stack_infos(self, expr_vars: dict[str, Any], ie: InlineExprWrapper) -> None:
    """
    Adds additional information on the expr vars used within the with statement of a InlineExprWrapper.

    Args:
        expr_vars: Dictionary containing the current scope's local expr variables.
        ie: The InlineExprWrapper instance.
    """
    from .helpers import ComputedVar
    from .manager import InlineExprWrapper

    self.add_note(_color_tag("\nInlineExpr stack infos:", "\033[0;33m"))

    def _format_var_per_plane(v: ComputedVar) -> str:
        return ("\n    " + (" " * (len(k) + 2))).join(v.to_str_per_plane(ie._format.num_planes))

    for k, v in sorted(expr_vars.items()):
        if k.startswith("_"):
            continue

        if isinstance(v, InlineExprWrapper):
            k = f"{k}.out"
            v = _format_var_per_plane(v.out)
        elif isinstance(v, ComputedVar):
            v = _format_var_per_plane(v)
        elif v is not None:
            with suppress(TypeError):
                v = str([str(x) for x in iter(v)])

        self.add_note("    " + _color_tag(f"{k}: ", "\033[1;37m") + str(v))

@classmethod
def catch(cls) -> CatchError[Self]:
    """
    Create a context manager that catches exceptions of this class type.

    Returns:
        CatchError[Self]: A context manager that will catch and store exceptions of type `cls`
            when used in a `with` block.
    """
    return CatchError(cls)