Jinja

https://jinja.palletsprojects.com/en/stable
Admin
Jinja is a fast, expressive, extensible templating engine that allows writing code similar to Python...
Tokens:111,500
Snippets:1,037
Trust Score:9.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install i18n translations globally

Source: https://jinja.palletsprojects.com/en/stable/extensions

Example of configuring the i18n extension by installing translations during environment creation.

```python
translations = get_gettext_translations()
env = Environment(extensions=["jinja2.ext.i18n"])
env.install_gettext_translations(translations)
```

--------------------------------

### Initialize FileSystemBytecodeCache

Source: https://jinja.palletsprojects.com/en/stable/api

Example of instantiating the built-in FileSystemBytecodeCache with a specific directory and filename pattern.

```python
>>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
```

--------------------------------

### Install Jinja via pip

Source: https://jinja.palletsprojects.com/en/stable/intro

Use pip to install the latest version of the Jinja2 package.

```bash
$ pip install Jinja2
```

--------------------------------

### min filter example

Source: https://jinja.palletsprojects.com/en/stable/templates

Returns the smallest item from a sequence. The example outputs 1.

```jinja
{{ [1, 2, 3]|min }}
    -> 1
```

--------------------------------

### Template Inheritance with Subdirectories

Source: https://jinja.palletsprojects.com/en/stable/templates

Example of extending a template located in a subdirectory using the FileSystemLoader.

```html
{% extends "layout/default.html" %}
```

--------------------------------

### Debug tag output example

Source: https://jinja.palletsprojects.com/en/stable/templates

Example output from the {% debug %} tag, showing the context, filters, and tests dictionaries. The output is truncated with ellipses for brevity.

```text
{'context': {'cycler': <class 'jinja2.utils.Cycler'>,
             ...,
             'namespace': <class 'jinja2.utils.Namespace'>},
 'filters': ['abs', 'attr', 'batch', 'capitalize', 'center', 'count', 'd',
             ..., 'urlencode', 'urlize', 'wordcount', 'wordwrap', 'xmlattr'],
 'tests': ['!=', '<', '<=', '==', '>', '>=', 'callable', 'defined',
           ..., 'odd', 'sameas', 'sequence', 'string', 'undefined', 'upper']}
```

--------------------------------

### Minimal Jinja Template Example

Source: https://jinja.palletsprojects.com/en/stable/templates

A basic HTML template demonstrating the use of a for-loop tag, variable expression, and a comment.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>My Webpage</title>
</head>
<body>
    <ul id="navigation">
    {% for item in navigation %}
        <li><a href="{{ item.href }}">{{ item.caption }}</a></li>
    {% endfor %}
    </ul>

    <h1>My Webpage</h1>
    {{ a_variable }}

    {# a comment #}
</body>
</html>
```

--------------------------------

### EvalContextModifier example

Source: https://jinja.palletsprojects.com/en/stable/extensions

Shows how to construct an EvalContextModifier node to change the autoescape setting in the eval context.

```python
EvalContextModifier(options=[Keyword('autoescape', Const(True))])
```

--------------------------------

### ModuleLoader usage example

Source: https://jinja.palletsprojects.com/en/stable/api

Creates a ModuleLoader with a path to precompiled templates. Templates can be precompiled with Environment.compile_templates().

```python
>>> loader = ModuleLoader('/path/to/compiled/templates')
```

--------------------------------

### Environment.install_gettext_callables

Source: https://jinja.palletsprojects.com/en/stable/extensions

Installs the given gettext, ngettext, pgettext, and npgettext callables into the environment. They should behave exactly like gettext.gettext(), gettext.ngettext(), gettext.pgettext() and gettext.npgettext().

```APIDOC
## Environment.install_gettext_callables

### Description
Installs the given gettext, ngettext, pgettext, and npgettext callables into the environment. They should behave exactly like gettext.gettext(), gettext.ngettext(), gettext.pgettext() and gettext.npgettext(). If newstyle is activated, the callables are wrapped to work like newstyle callables.

### Method
install_gettext_callables

### Parameters
- **gettext** (callable) - Required - The gettext callable.
- **ngettext** (callable) - Required - The ngettext callable.
- **newstyle** (bool) - Optional - If True, enables new-style gettext support. Default is False.
- **pgettext** (callable) - Optional - The pgettext callable.
- **npgettext** (callable) - Optional - The npgettext callable.

### Changelog
- Changed in version 3.0: Added pgettext and npgettext.
- Added in version 2.5: Added new-style gettext support.
```

--------------------------------

### Mako template example

Source: https://jinja.palletsprojects.com/en/stable/switching

A Mako template using inheritance, defs, and a for loop. This is shown as a comparison to the Jinja version.

```mako
<%inherit file="layout.html" />
<%def name="title()">Page Title</%def>
<ul>
% for item in list:
    <li>${item}</li>
% endfor
</ul>

```

--------------------------------

### Recommended setup with PackageLoader

Source: https://jinja.palletsprojects.com/en/stable/api

Recommended configuration that enables autoescaping for .html, .htm, and .xml templates, and disables it by default for other extensions. Uses PackageLoader to load templates from a package.

```python
from jinja2 import Environment, PackageLoader, select_autoescape
env = Environment(autoescape=select_autoescape(['html', 'htm', 'xml']),
                  loader=PackageLoader('mypackage'))

```

--------------------------------

### Environment.install_gettext_translations

Source: https://jinja.palletsprojects.com/en/stable/extensions

Installs a translation globally for the environment. The translations object must implement gettext, ngettext, and optionally pgettext and npgettext.

```APIDOC
## Environment.install_gettext_translations

### Description
Installs a translation globally for the environment. The translations object must implement gettext, ngettext, and optionally pgettext and npgettext. Supported objects include gettext.NullTranslations, gettext.GNUTranslations, and Babel's Translations.

### Method
install_gettext_translations

### Parameters
- **translations** (object) - Required - The translation object implementing gettext, ngettext, and optionally pgettext and npgettext.
- **newstyle** (bool) - Optional - If True, enables new-style gettext support. Default is False.

### Changelog
- Changed in version 3.0: Added pgettext and npgettext.
- Changed in version 2.5: Added new-style gettext support.
```

--------------------------------

### jinja2.Environment.install_gettext_callables()

Source: https://jinja.palletsprojects.com/en/stable/extensions

Installs gettext callables on the environment for custom translation handling. This method is part of the i18n extension.

```APIDOC
## jinja2.Environment.install_gettext_callables()

### Description
Installs gettext callables on the environment for custom translation handling. This method is part of the i18n extension.

### Method
install_gettext_callables

### Endpoint
jinja2.Environment.install_gettext_callables()

### Parameters
No parameters documented.

### Response
No response documented.
```

--------------------------------

### Environment.install_null_translations

Source: https://jinja.palletsprojects.com/en/stable/extensions

Installs no-op gettext functions. This is useful for preparing an application for internationalization without implementing the full system yet.

```APIDOC
## Environment.install_null_translations

### Description
Installs no-op gettext functions. This is useful if you want to prepare the application for internationalization but don't want to implement the full system yet.

### Method
install_null_translations

### Parameters
- **newstyle** (bool) - Optional - If True, enables new-style gettext support. Default is False.

### Changelog
- Changed in version 2.5: Added new-style gettext support.
```

--------------------------------

### Arithmetic Operators

Source: https://jinja.palletsprojects.com/en/stable/templates

Examples of basic arithmetic operations in Jinja templates.

```jinja2
{{ 1 + 1 }}
```

```jinja2
{{ 3 - 2 }}
```

```jinja2
{{ 1 / 2 }}
```

```jinja2
{{ 20 // 7 }}
```

```jinja2
{{ 11 % 7 }}
```

```jinja2
{{ 2 * 2 }}
```

```jinja2
{{ '=' * 80 }}
```

```jinja2
{{ 2**3 }}
```

```jinja2
{{ 3**3**3 }}
```

--------------------------------

### Default template whitespace behavior

Source: https://jinja.palletsprojects.com/en/stable/templates

An example template demonstrating how whitespace is preserved when trim_blocks and lstrip_blocks are disabled.

```jinja
<div>
    {% if True %}
        yay
    {% endif %}
</div>

```

--------------------------------

### Import and Include Context Directives

Source: https://jinja.palletsprojects.com/en/stable/templates

Examples of explicitly controlling context passing for imports and includes in Jinja templates.

```jinja2
{% from 'forms.html' import input with context %}
{% include 'header.html' without context %}
```

--------------------------------

### Dumping TemplateStream to File

Source: https://jinja.palletsprojects.com/en/stable/api

Example of using the dump method on a TemplateStream to write the rendered output directly to a file.

```python
Template('Hello {{ name }}!').stream(name='foo').dump('hello.html')
```

--------------------------------

### Jinja loop.cycle method

Source: https://jinja.palletsprojects.com/en/stable/switching

In Jinja, the loop context has a cycle method. This example alternates 'odd' and 'even' classes.

```jinja
{% for user in users %}
    <li class="{{ loop.cycle('odd', 'even') }}">{{ user }}</li>
{% endfor %}

```

--------------------------------

### Default rendering output

Source: https://jinja.palletsprojects.com/en/stable/templates

The rendered output of the default template example, showing blank lines preserved inside the div.

```text
<div>

        yay

</div>

```

--------------------------------

### DictLoader usage example

Source: https://jinja.palletsprojects.com/en/stable/api

Creates a DictLoader with a mapping of template names to source strings. Useful for unit testing. Auto reloading is disabled by default.

```python
>>> loader = DictLoader({'index.html': 'source here'})
```

--------------------------------

### max filter example

Source: https://jinja.palletsprojects.com/en/stable/templates

Returns the largest item from a sequence. The example outputs 3.

```jinja
{{ [1, 2, 3]|max }}
    -> 3
```

--------------------------------

### FileSystemLoader with a list of directories

Source: https://jinja.palletsprojects.com/en/stable/api

Creates a FileSystemLoader that searches multiple directories in order, stopping at the first matching template.

```python
loader = FileSystemLoader(["/override/templates", "/default/templates"])
```

--------------------------------

### Jinja 2.0 Context Limitation Example

Source: https://jinja.palletsprojects.com/en/stable/templates

An example of a pattern that failed to access loop variables in Jinja 2.0, where included templates could not access variables defined in the parent template.

```jinja2
{% for box in boxes %}
    {% include "render_box.html" %}
{% endfor %}
```

--------------------------------

### PrefixLoader usage example

Source: https://jinja.palletsprojects.com/en/stable/api

Creates a PrefixLoader with a dict mapping prefixes to loaders. The default delimiter is '/', which can be changed with the delimiter argument. Loading 'app1/index.html' loads from the app1 package.

```python
loader = PrefixLoader({
    'app1':     PackageLoader('mypackage.app1'),
    'app2':     PackageLoader('mypackage.app2')
})
```

--------------------------------

### Filter chaining example: {{ name|striptags|title }}

Source: https://jinja.palletsprojects.com/en/stable/templates

Shows how to chain filters with a pipe symbol. The output of one filter is applied to the next. This example removes HTML tags from the variable 'name' and then title-cases the result.

```jinja
{{ name|striptags|title }}
```

--------------------------------

### xmlattr filter usage example

Source: https://jinja.palletsprojects.com/en/stable/templates

Shows how to use the xmlattr filter to generate an HTML attribute string from a dict. The example includes a template snippet and its resulting output. Note that keys with spaces, /, >, or = are not allowed and will raise a ValueError.

```jinja
<ul{{ {'class': 'my_list', 'missing': none,
        'id': 'list-%d'|format(variable)}|xmlattr }}>
...
</ul>

```

```html
<ul class="my_list" id="list-42">
...
</ul>

```

--------------------------------

### OverlayScope usage example

Source: https://jinja.palletsprojects.com/en/stable/extensions

Shows how to create an OverlayScope node with a context obtained via call_method('get_context') and a body list. This is used to introduce arbitrary variables into a sub scope from a dictionary-like object.

```python
OverlayScope(context=self.call_method('get_context'),
             body=[...])
```

--------------------------------

### Environment.uninstall_gettext_translations

Source: https://jinja.palletsprojects.com/en/stable/extensions

Uninstalls the environment's globally installed translation.

```APIDOC
## Environment.uninstall_gettext_translations

### Description
Uninstalls the environment's globally installed translation.

### Method
uninstall_gettext_translations

### Parameters
None.
```

--------------------------------

### Environment Class

Source: https://jinja.palletsprojects.com/en/stable/api

Documentation for the Jinja2 Environment class constructor and its initialization parameters.

```APIDOC
## Environment Class

### Description
Creates a Jinja2 environment that holds configuration, filters, tests, globals, and other shared variables. It is the core component for loading and rendering templates.

### Constructor
`Environment([options])`

### Parameters
#### Options
- **block_start_string** (string) - Optional - The string marking the beginning of a block. Defaults to `'{%'`.
- **block_end_string** (string) - Optional - The string marking the end of a block. Defaults to `'%}'`.
- **variable_start_string** (string) - Optional - The string marking the beginning of a print statement. Defaults to `'{{'`.
- **variable_end_string** (string) - Optional - The string marking the end of a print statement. Defaults to `'}}'`.
- **comment_start_string** (string) - Optional - The string marking the beginning of a comment. Defaults to `'{#'`.
- **comment_end_string** (string) - Optional - The string marking the end of a comment. Defaults to `'#}'`.
- **line_statement_prefix** (string) - Optional - Prefix for line based statements.
- **line_comment_prefix** (string) - Optional - Prefix for line based comments.
- **trim_blocks** (boolean) - Optional - If `True`, the first newline after a block is removed. Defaults to `False`.
- **lstrip_blocks** (boolean) - Optional - If `True`, leading spaces and tabs are stripped from the start of a line to a block. Defaults to `False`.
- **newline_sequence** (string) - Optional - The sequence that starts a newline. Must be one of `'\r'`, `'\n'` or `'\r\n'`. Defaults to `'\n'`.
- **keep_trailing_newline** (boolean) - Optional - Preserve the trailing newline when rendering templates. Defaults to `False`.
- **extensions** (list) - Optional - List of Jinja extensions to use. Can be import paths as strings or extension classes.
- **optimized** (boolean) - Optional - Should the optimizer be enabled? Defaults to `True`.
- **undefined** (class) - Optional - `Undefined` or a subclass used to represent undefined values in the template.
- **finalize** (callable) - Optional - A callable that processes the result of a variable expression before output.
- **autoescape** (boolean or callable) - Optional - If `True`, XML/HTML autoescaping is enabled by default. Can also be a callable that takes the template name and returns `True` or `False`.
- **loader** (loader) - Optional - The template loader for this environment.
- **cache_size** (integer) - Optional - The size of the cache. Defaults to `400`. If `0`, templates are recompiled all the time; if `-1`, the cache is never cleaned.
- **auto_reload** (boolean) - Optional - If `True` (default), the loader checks if the source changed and reloads the template if needed.
- **bytecode_cache** (object) - Optional - A bytecode cache object to cache internal Jinja bytecode.
- **enable_async** (boolean) - Optional - If `True`, enables async template execution.

### Notes
- Instances may be modified if not shared and if no template has been loaded yet.
- Modifications after the first template is loaded may lead to undefined behavior.
```

--------------------------------

### Add extensions at environment creation

Source: https://jinja.palletsprojects.com/en/stable/extensions

Pass a list of extension classes or import paths to the extensions parameter of the Environment constructor.

```python
jinja_env = Environment(extensions=['jinja2.ext.i18n'])
```

--------------------------------

### Configure Environment with PackageLoader

Source: https://jinja.palletsprojects.com/en/stable/api

Initializes a Jinja Environment using PackageLoader to look up templates in a package folder and enables autoescaping.

```python
from jinja2 import Environment, PackageLoader, select_autoescape
env = Environment(
    loader=PackageLoader("yourapp"),
    autoescape=select_autoescape()
)
```

--------------------------------

### Extension.attr usage

Source: https://jinja.palletsprojects.com/en/stable/extensions

Example of using the attr method to return an attribute node for the current extension.

```python
self.attr('_my_attribute', lineno=lineno)
```

--------------------------------

### Include Tag with Context and Missing Handling

Source: https://jinja.palletsprojects.com/en/stable/templates

Demonstrates using without context, ignore missing, and combined options for the include tag.

```jinja2
{% include "sidebar.html" without context %}
{% include "sidebar.html" ignore missing %}
{% include "sidebar.html" ignore missing with context %}
{% include "sidebar.html" ignore missing without context %}
```

--------------------------------

### Use colon with line statements

Source: https://jinja.palletsprojects.com/en/stable/templates

Statements that start a block can end with a colon for improved readability.

```jinja2
# for item in seq:
    ...
# endfor
```

--------------------------------

### Compare line statements with standard blocks

Source: https://jinja.palletsprojects.com/en/stable/templates

Demonstrates that line statements (using # prefix) are equivalent to standard block syntax.

```jinja2
<ul>
# for item in seq
    <li>{{ item }}</li>
# endfor
</ul>

<ul>
{% for item in seq %}
    <li>{{ item }}</li>
{% endfor %}
</ul>
```

--------------------------------

### rejectattr filter equivalent generator comprehensions

Source: https://jinja.palletsprojects.com/en/stable/templates

Python generator comprehensions equivalent to the rejectattr filter examples.

```python
(user for user in users if not user.is_active)
(user for user in users if not test_none(user.email))
```

--------------------------------

### Render a template with context

Source: https://jinja.palletsprojects.com/en/stable/api

Demonstrates the two equivalent ways to pass context variables to the render method.

```python
template.render(knights='that say nih')
template.render({'knights': 'that say nih'})
```

--------------------------------

### reject filter equivalent generator comprehension

Source: https://jinja.palletsprojects.com/en/stable/templates

Python generator comprehension equivalent to the reject filter example.

```python
(n for n in numbers if not test_odd(n))
```

--------------------------------

### Environment.overlay

Source: https://jinja.palletsprojects.com/en/stable/api

Documentation for the Environment.overlay method, which creates a new overlay environment that shares data with the current environment.

```APIDOC
## Environment.overlay

### Description
Creates a new overlay environment that shares all the data with the current environment except for cache and the overridden attributes. Extensions cannot be removed for an overlayed environment. An overlayed environment automatically gets all the extensions of the environment it is linked to plus optional extra extensions.

### Method
overlay

### Signature
overlay([options])

### Parameters
- **block_start_string** (str) - Optional - The string that marks the beginning of a block.
- **block_end_string** (str) - Optional - The string that marks the end of a block.
- **variable_start_string** (str) - Optional - The string that marks the beginning of a variable.
- **variable_end_string** (str) - Optional - The string that marks the end of a variable.
- **comment_start_string** (str) - Optional - The string that marks the beginning of a comment.
- **comment_end_string** (str) - Optional - The string that marks the end of a comment.
- **line_statement_prefix** (str | None) - Optional - The prefix for line statements.
- **line_comment_prefix** (str | None) - Optional - The prefix for line comments.
- **trim_blocks** (bool) - Optional - If True, the first newline after a block is removed.
- **lstrip_blocks** (bool) - Optional - If True, leading whitespace is stripped from the beginning of a line to a block.
- **newline_sequence** (Literal['\n', '\r\n', '\r']) - Optional - The sequence that starts a newline.
- **keep_trailing_newline** (bool) - Optional - If True, the trailing newline is kept.
- **extensions** (Sequence[str | Type[Extension]]) - Optional - A list of extensions to use.
- **optimized** (bool) - Optional - If True, the compiler optimizes the template.
- **undefined** (Type[Undefined]) - Optional - The undefined type to use.
- **finalize** (Callable[[...], Any] | None) - Optional - A callable that is called with the result of each expression.
- **autoescape** (bool | Callable[[str | None], bool]) - Optional - If True, autoescaping is enabled.
- **loader** (BaseLoader | None) - Optional - The template loader.
- **cache_size** (int) - Optional - The size of the cache.
- **auto_reload** (bool) - Optional - If True, templates are reloaded when they change.
- **bytecode_cache** (BytecodeCache | None) - Optional - The bytecode cache.
- **enable_async** (bool) - Optional - If True, async mode is enabled.

### Return Type
te.Self

### Notes
Creating overlays should happen after the initial environment was set up completely. Not all attributes are truly linked, some are just copied over so modifications on the original environment may not shine through.

Changed in version 3.1.5: `enable_async` is applied correctly.
Changed in version 3.1.2: Added the `newline_sequence`, `keep_trailing_newline`, and `enable_async` parameters to match `__init__`.
```

--------------------------------

### Register FragmentCacheExtension in Environment

Source: https://jinja.palletsprojects.com/en/stable/extensions

Configures the Jinja Environment to use the FragmentCacheExtension and initializes the cache backend.

```python
from jinja2 import Environment
from cachelib import SimpleCache

env = Environment(extensions=[FragmentCacheExtension])
env.fragment_cache = SimpleCache()
```

--------------------------------

### jinja2.Environment.install_null_translations()

Source: https://jinja.palletsprojects.com/en/stable/extensions

Installs null translations on the environment, which are used when no translations are available. This method is part of the i18n extension.

```APIDOC
## jinja2.Environment.install_null_translations()

### Description
Installs null translations on the environment, which are used when no translations are available. This method is part of the i18n extension.

### Method
install_null_translations

### Endpoint
jinja2.Environment.install_null_translations()

### Parameters
No parameters documented.

### Response
No response documented.
```

--------------------------------

### ChoiceLoader usage example

Source: https://jinja.palletsprojects.com/en/stable/api

Creates a ChoiceLoader with a list of loaders. If a template is not found by one loader, the next is tried. Useful for allowing users to override builtin templates from a different location.

```python
>>> loader = ChoiceLoader([
...     FileSystemLoader('/path/to/user/templates'),
...     FileSystemLoader('/path/to/system/templates')
... ])
```

--------------------------------

### title

Source: https://jinja.palletsprojects.com/en/stable/templates

Returns a titlecased version of the value: words start with uppercase letters, remaining characters are lowercase.

```APIDOC
## title

### Description
Return a titlecased version of the value. I.e. words will start with uppercase letters, all remaining characters are lowercase.

### Parameters
- **s** (str) - Required - The string to titlecase.
```

--------------------------------

### attr

Source: https://jinja.palletsprojects.com/en/stable/templates

Get an attribute of an object. Works like `foo.bar` but returns undefined if the attribute doesn't exist.

```APIDOC
## attr

### Description
Get an attribute of an object. `foo|attr("bar")` works like `foo.bar`, but returns undefined instead of falling back to `foo["bar"]` if the attribute doesn't exist.

### Signature
`attr(obj: Any, name: str) -> jinja2.runtime.Undefined | Any`

### Parameters
- **obj** (Any) - The object to get the attribute from.
- **name** (str) - The name of the attribute.

### Notes
See Notes on subscriptions for more details.
```

--------------------------------

### Required block example files

Source: https://jinja.palletsprojects.com/en/stable/templates

Three template files demonstrating required blocks. page.txt declares a required block, issue.txt extends page.txt without overriding it, and bug_report.txt extends issue.txt and overrides the block. Rendering page.txt or issue.txt raises TemplateRuntimeError; bug_report.txt renders successfully.

```jinja
{% block body required %}{% endblock %}

```

```jinja
{% extends "page.txt" %}

```

```jinja
{% extends "issue.txt" %}
{% block body %}Provide steps to demonstrate the bug.{% endblock %}

```

--------------------------------

### Render a template asynchronously

Source: https://jinja.palletsprojects.com/en/stable/api

Example of using render_async to render a template as a coroutine, which requires the async feature to be enabled.

```python
await template.render_async(knights='that say nih; asynchronously')
```

--------------------------------

### Include Tag with Template Lists

Source: https://jinja.palletsprojects.com/en/stable/templates

Provides a list of templates to try in order, optionally ignoring if none exist.

```jinja2
{% include ['page_detailed.html', 'page.html'] %}
{% include ['special_sidebar.html', 'sidebar.html'] ignore missing %}
```

--------------------------------

### Jinja test with is operator

Source: https://jinja.palletsprojects.com/en/stable/switching

Jinja has tests used with the is operator, which is not the same as the Python operator. This example checks if user_id is odd.

```jinja
{% if user.user_id is odd %}
    {{ user.username|e }} is odd
{% else %}
    hmm. {{ user.username|e }} looks pretty normal
{% endif %}

```

--------------------------------

### Manually disabling lstrip_blocks with a plus sign

Source: https://jinja.palletsprojects.com/en/stable/templates

Using a plus sign at the start of a block to prevent lstrip_blocks behavior.

```jinja
<div>
        {%+ if something %}yay{% endif %}
</div>

```

--------------------------------

### select_template(names, parent=None, globals=None)

Source: https://jinja.palletsprojects.com/en/stable/api

Tries loading multiple template names in order and returns the first that can be loaded. Raises TemplatesNotFound if none can be loaded.

```APIDOC
## select_template(names, parent=None, globals=None)

### Description
Like `get_template()`, but tries loading multiple names. If none of the names can be loaded a `TemplatesNotFound` exception is raised.

### Method
select_template

### Parameters
- **names** (Iterable[str | Template]) - Required - List of template names to try loading in order.
- **parent** (str | None) - Optional - The name of the parent template importing this template. `join_path()` can be used to implement name transformations with this.
- **globals** (MutableMapping[str, Any] | None) - Optional - Extend the environment `globals` with these extra variables available for all renders of this template. If the template has already been loaded and cached, its globals are updated with any new items.

### Return Type
Template

### Changelog
- Changed in version 3.0: If a template is loaded from cache, `globals` will update the template's globals instead of ignoring the new values.
- Changed in version 2.11: If `names` is `Undefined`, an `UndefinedError` is raised instead. If no templates were found and `names` contains `Undefined`, the message is more helpful.
- Changed in version 2.4: If `names` contains a `Template` object it is returned unchanged.
- Added in version 2.3.
```

--------------------------------

### Basic Include Tag Usage

Source: https://jinja.palletsprojects.com/en/stable/templates

Renders header and footer templates within the current template.

```jinja2
{% include 'header.html' %}
Body goes here.
{% include 'footer.html' %}
```

--------------------------------

### reject filter example

Source: https://jinja.palletsprojects.com/en/stable/templates

Filters a sequence by rejecting objects that pass a test. If no test is specified, each object is evaluated as a boolean.

```jinja
{{ numbers|reject("odd") }}
```

--------------------------------

### map filter equivalent generator comprehensions

Source: https://jinja.palletsprojects.com/en/stable/templates

Python generator comprehensions equivalent to the map filter examples. Shown for comparison.

```python
(u.username for u in users)
(getattr(u, "username", "Anonymous") for u in users)
(do_lower(x) for x in titles)
```

--------------------------------

### Jinja equivalent with Mako-like configuration

Source: https://jinja.palletsprojects.com/en/stable/switching

This Jinja template uses the Mako-like configuration to achieve similar functionality to the Mako example. It uses block and extends instead of inherit and def.

```jinja
<% extends "layout.html" %>
<% block title %>Page Title<% endblock %>
<% block body %>
<ul>
% for item in list:
    <li>${item}</li>
% endfor
</ul>
<% endblock %>

```

--------------------------------

### map filter with filter name

Source: https://jinja.palletsprojects.com/en/stable/templates

Invokes a filter by name on each item in a sequence. Example applies the lower filter to each title.

```jinja
Users on this page: {{ titles|map('lower')|join(', ') }}
```

--------------------------------

### Using SandboxedEnvironment to render untrusted templates

Source: https://jinja.palletsprojects.com/en/stable/sandbox

Creates a sandboxed environment and renders a template that calls a function. Attempting to access the function's __code__ attribute raises a SecurityError, demonstrating the sandbox's protection against unsafe attribute access.

```python
>>> from jinja2.sandbox import SandboxedEnvironment
>>> env = SandboxedEnvironment()
>>> func = lambda: "Hello, Sandbox!"
>>> env.from_string("{{ func() }}").render(func=func)
'Hello, Sandbox!'
>>> env.from_string("{{ func.__code__.co_code }}").render(func=func)
Traceback (most recent call last):
  ...
SecurityError: access to attribute '__code__' of 'function' object is unsafe.
```
Tokens:
Raw