1import typing as t
2
3if t.TYPE_CHECKING:
4    from .runtime import Undefined
5
6
7class TemplateError(Exception):
8    """Baseclass for all template errors."""
9
10    def __init__(self, message: t.Optional[str] = None) -> None:
11        super().__init__(message)
12
13    @property
14    def message(self) -> t.Optional[str]:
15        return self.args[0] if self.args else None
16
17
18class TemplateNotFound(IOError, LookupError, TemplateError):
19    """Raised if a template does not exist.
20
21    .. versionchanged:: 2.11
22        If the given name is :class:`Undefined` and no message was
23        provided, an :exc:`UndefinedError` is raised.
24    """
25
26    # Silence the Python warning about message being deprecated since
27    # it's not valid here.
28    message: t.Optional[str] = None
29
30    def __init__(
31        self,
32        name: t.Optional[t.Union[str, "Undefined"]],
33        message: t.Optional[str] = None,
34    ) -> None:
35        IOError.__init__(self, name)
36
37        if message is None:
38            from .runtime import Undefined
39
40            if isinstance(name, Undefined):
41                name._fail_with_undefined_error()
42
43            message = name
44
45        self.message = message
46        self.name = name
47        self.templates = [name]
48
49    def __str__(self) -> str:
50        return str(self.message)
51
52
53class TemplatesNotFound(TemplateNotFound):
54    """Like :class:`TemplateNotFound` but raised if multiple templates
55    are selected.  This is a subclass of :class:`TemplateNotFound`
56    exception, so just catching the base exception will catch both.
57
58    .. versionchanged:: 2.11
59        If a name in the list of names is :class:`Undefined`, a message
60        about it being undefined is shown rather than the empty string.
61
62    .. versionadded:: 2.2
63    """
64
65    def __init__(
66        self,
67        names: t.Sequence[t.Union[str, "Undefined"]] = (),
68        message: t.Optional[str] = None,
69    ) -> None:
70        if message is None:
71            from .runtime import Undefined
72
73            parts = []
74
75            for name in names:
76                if isinstance(name, Undefined):
77                    parts.append(name._undefined_message)
78                else:
79                    parts.append(name)
80
81            parts_str = ", ".join(map(str, parts))
82            message = f"none of the templates given were found: {parts_str}"
83
84        super().__init__(names[-1] if names else None, message)
85        self.templates = list(names)
86
87
88class TemplateSyntaxError(TemplateError):
89    """Raised to tell the user that there is a problem with the template."""
90
91    def __init__(
92        self,
93        message: str,
94        lineno: int,
95        name: t.Optional[str] = None,
96        filename: t.Optional[str] = None,
97    ) -> None:
98        super().__init__(message)
99        self.lineno = lineno
100        self.name = name
101        self.filename = filename
102        self.source: t.Optional[str] = None
103
104        # this is set to True if the debug.translate_syntax_error
105        # function translated the syntax error into a new traceback
106        self.translated = False
107
108    def __str__(self) -> str:
109        # for translated errors we only return the message
110        if self.translated:
111            return t.cast(str, self.message)
112
113        # otherwise attach some stuff
114        location = f"line {self.lineno}"
115        name = self.filename or self.name
116        if name:
117            location = f'File "{name}", {location}'
118        lines = [t.cast(str, self.message), "  " + location]
119
120        # if the source is set, add the line to the output
121        if self.source is not None:
122            try:
123                line = self.source.splitlines()[self.lineno - 1]
124            except IndexError:
125                pass
126            else:
127                lines.append("    " + line.strip())
128
129        return "\n".join(lines)
130
131    def __reduce__(self):  # type: ignore
132        # https://bugs.python.org/issue1692335 Exceptions that take
133        # multiple required arguments have problems with pickling.
134        # Without this, raises TypeError: __init__() missing 1 required
135        # positional argument: 'lineno'
136        return self.__class__, (self.message, self.lineno, self.name, self.filename)
137
138
139class TemplateAssertionError(TemplateSyntaxError):
140    """Like a template syntax error, but covers cases where something in the
141    template caused an error at compile time that wasn't necessarily caused
142    by a syntax error.  However it's a direct subclass of
143    :exc:`TemplateSyntaxError` and has the same attributes.
144    """
145
146
147class TemplateRuntimeError(TemplateError):
148    """A generic runtime error in the template engine.  Under some situations
149    Jinja may raise this exception.
150    """
151
152
153class UndefinedError(TemplateRuntimeError):
154    """Raised if a template tries to operate on :class:`Undefined`."""
155
156
157class SecurityError(TemplateRuntimeError):
158    """Raised if a template tries to do something insecure if the
159    sandbox is enabled.
160    """
161
162
163class FilterArgumentError(TemplateRuntimeError):
164    """This error is raised if a filter was called with inappropriate
165    arguments
166    """
167