jinja2 API Reference
Full documentation for jinja2 (3.1.4)
jinja2.BaseLoader
Python Library Documentation: class BaseLoader in module jinja2.loaders class BaseLoader(builtins.object) | Baseclass for all loaders. Subclass this and override `get_source` to | implement a custom loading mechanism. The environment provides a | `get_template` method that calls the loader's `load` method to get the | :class:`Template` object. | | A very basic example for a loader that looks up templates on the file | system could look like this:: | | from jinja2 import BaseLoader, TemplateNotFound | from os.path import join, exists, getmtime | | class MyLoader(BaseLoader): | | def __init__(self, path): | self.path = path | | def get_source(self, environment, template): | path = join(self.path, template) | if not exists(path): | raise TemplateNotFound(template) | mtime = getmtime(path) | with open(path) as f: | source = f.read() | return source, path, lambda: mtime == getmtime(path) | | Methods defined here: | | get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]] | Get the template source, filename and reload helper for a template. | It's passed the environment and template name and has to return a | tuple in the form ``(source, filename, uptodate)`` or raise a | `TemplateNotFound` error if it can't locate the template. | | The source part of the returned tuple must be the source of the | template as a string. The filename should be the name of the | file on the filesystem if it was loaded from there, otherwise | ``None``. The filename is used by Python for the tracebacks | if no loader extension is used. | | The last item in the tuple is the `uptodate` function. If auto | reloading is enabled it's always called to check if the template | changed. No arguments are passed so the function must store the | old state somewhere (for example in a closure). If it returns `False` | the template will be reloaded. | | list_templates(self) -> List[str] | Iterates over all templates. If the loader does not support that | it should raise a :exc:`TypeError` which is the default behavior. | | load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template' | Loads a template. This method looks up the template in the cache | or loads one by calling :meth:`get_source`. Subclasses should not | override this method as loaders working on collections of other | loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`) | will not call this method but `get_source` directly. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | has_source_access = True
jinja2.BytecodeCache
Python Library Documentation: class BytecodeCache in module jinja2.bccache class BytecodeCache(builtins.object) | To implement your own bytecode cache you have to subclass this class | and override :meth:`load_bytecode` and :meth:`dump_bytecode`. Both of | these methods are passed a :class:`~jinja2.bccache.Bucket`. | | A very basic bytecode cache that saves the bytecode on the file system:: | | from os import path | | class MyCache(BytecodeCache): | | def __init__(self, directory): | self.directory = directory | | def load_bytecode(self, bucket): | filename = path.join(self.directory, bucket.key) | if path.exists(filename): | with open(filename, 'rb') as f: | bucket.load_bytecode(f) | | def dump_bytecode(self, bucket): | filename = path.join(self.directory, bucket.key) | with open(filename, 'wb') as f: | bucket.write_bytecode(f) | | A more advanced version of a filesystem based bytecode cache is part of | Jinja. | | Methods defined here: | | clear(self) -> None | Clears the cache. This method is not used by Jinja but should be | implemented to allow applications to clear the bytecode cache used | by a particular environment. | | dump_bytecode(self, bucket: jinja2.bccache.Bucket) -> None | Subclasses have to override this method to write the bytecode | from a bucket back to the cache. If it unable to do so it must not | fail silently but raise an exception. | | get_bucket(self, environment: 'Environment', name: str, filename: Optional[str], source: str) -> jinja2.bccache.Bucket | Return a cache bucket for the given template. All arguments are | mandatory but filename may be `None`. | | get_cache_key(self, name: str, filename: Optional[str] = None) -> str | Returns the unique hash key for this template name. | | get_source_checksum(self, source: str) -> str | Returns a checksum for the source. | | load_bytecode(self, bucket: jinja2.bccache.Bucket) -> None | Subclasses have to override this method to load bytecode into a | bucket. If they are not able to find code in the cache for the | bucket, it must not do anything. | | set_bucket(self, bucket: jinja2.bccache.Bucket) -> None | Put the bucket into the cache. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
jinja2.ChainableUndefined
Python Library Documentation: class ChainableUndefined in module jinja2.runtime class ChainableUndefined(Undefined) | ChainableUndefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None | | An undefined that is chainable, where both ``__getattr__`` and | ``__getitem__`` return itself rather than raising an | :exc:`UndefinedError`. | | >>> foo = ChainableUndefined(name='foo') | >>> str(foo.bar['baz']) | '' | >>> foo.bar['baz'] + 42 | Traceback (most recent call last): | ... | jinja2.exceptions.UndefinedError: 'foo' is undefined | | .. versionadded:: 2.11.0 | | Method resolution order: | ChainableUndefined | Undefined | builtins.object | | Methods defined here: | | __getattr__(self, _: str) -> 'ChainableUndefined' | | __getitem__ = __getattr__(self, _: str) -> 'ChainableUndefined' | | __html__(self) -> str | | ---------------------------------------------------------------------- | Methods inherited from Undefined: | | __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | async __aiter__(self) -> AsyncIterator[Any] | | __bool__(self) -> bool | | __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __eq__(self, other: Any) -> bool | Return self==value. | | __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __hash__(self) -> int | Return hash(self). | | __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None | Initialize self. See help(type(self)) for accurate signature. | | __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __iter__(self) -> Iterator[Any] | | __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __len__(self) -> int | | __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __ne__(self, other: Any) -> bool | Return self!=value. | | __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __repr__(self) -> str | Return repr(self). | | __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __str__(self) -> str | Return str(self). | | __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
jinja2.ChoiceLoader
Python Library Documentation: class ChoiceLoader in module jinja2.loaders
class ChoiceLoader(BaseLoader)
| ChoiceLoader(loaders: Sequence[jinja2.loaders.BaseLoader]) -> None
|
| This loader works like the `PrefixLoader` just that no prefix is
| specified. If a template could not be found by one loader the next one
| is tried.
|
| >>> loader = ChoiceLoader([
| ... FileSystemLoader('/path/to/user/templates'),
| ... FileSystemLoader('/path/to/system/templates')
| ... ])
|
| This is useful if you want to allow users to override builtin templates
| from a different location.
|
| Method resolution order:
| ChoiceLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, loaders: Sequence[jinja2.loaders.BaseLoader]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
jinja2.DebugUndefined
Python Library Documentation: class DebugUndefined in module jinja2.runtime
class DebugUndefined(Undefined)
| DebugUndefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
|
| An undefined that returns the debug info when printed.
|
| >>> foo = DebugUndefined(name='foo')
| >>> str(foo)
| '{{ foo }}'
| >>> not foo
| True
| >>> foo + 42
| Traceback (most recent call last):
| ...
| jinja2.exceptions.UndefinedError: 'foo' is undefined
|
| Method resolution order:
| DebugUndefined
| Undefined
| builtins.object
|
| Methods defined here:
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Methods inherited from Undefined:
|
| __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| async __aiter__(self) -> AsyncIterator[Any]
|
| __bool__(self) -> bool
|
| __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __getattr__(self, name: str) -> Any
|
| __getitem__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __hash__(self) -> int
| Return hash(self).
|
| __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __iter__(self) -> Iterator[Any]
|
| __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __len__(self) -> int
|
| __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ne__(self, other: Any) -> bool
| Return self!=value.
|
| __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __repr__(self) -> str
| Return repr(self).
|
| __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
jinja2.DictLoader
Python Library Documentation: class DictLoader in module jinja2.loaders
class DictLoader(BaseLoader)
| DictLoader(mapping: Mapping[str, str]) -> None
|
| Loads a template from a Python dict mapping template names to
| template source. This loader is useful for unittesting:
|
| >>> loader = DictLoader({'index.html': 'source here'})
|
| Because auto reloading is rarely useful this is disabled per default.
|
| Method resolution order:
| DictLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, mapping: Mapping[str, str]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, NoneType, Callable[[], bool]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
jinja2.Environment
Python Library Documentation: class Environment in module jinja2.environment
class Environment(builtins.object)
| Environment(block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, loader: Optional[ForwardRef('BaseLoader')] = None, cache_size: int = 400, auto_reload: bool = True, bytecode_cache: Optional[ForwardRef('BytecodeCache')] = None, enable_async: bool = False)
|
| The core component of Jinja is the `Environment`. It contains
| important shared variables like configuration, filters, tests,
| globals and others. Instances of this class may be modified if
| they are not shared and if no template was loaded so far.
| Modifications on environments after the first template was loaded
| will lead to surprising effects and undefined behavior.
|
| Here are the possible initialization parameters:
|
| `block_start_string`
| The string marking the beginning of a block. Defaults to ``'{%'``.
|
| `block_end_string`
| The string marking the end of a block. Defaults to ``'%}'``.
|
| `variable_start_string`
| The string marking the beginning of a print statement.
| Defaults to ``'{{'``.
|
| `variable_end_string`
| The string marking the end of a print statement. Defaults to
| ``'}}'``.
|
| `comment_start_string`
| The string marking the beginning of a comment. Defaults to ``'{#'``.
|
| `comment_end_string`
| The string marking the end of a comment. Defaults to ``'#}'``.
|
| `line_statement_prefix`
| If given and a string, this will be used as prefix for line based
| statements. See also :ref:`line-statements`.
|
| `line_comment_prefix`
| If given and a string, this will be used as prefix for line based
| comments. See also :ref:`line-statements`.
|
| .. versionadded:: 2.2
|
| `trim_blocks`
| If this is set to ``True`` the first newline after a block is
| removed (block, not variable tag!). Defaults to `False`.
|
| `lstrip_blocks`
| If this is set to ``True`` leading spaces and tabs are stripped
| from the start of a line to a block. Defaults to `False`.
|
| `newline_sequence`
| The sequence that starts a newline. Must be one of ``'\r'``,
| ``'\n'`` or ``'\r\n'``. The default is ``'\n'`` which is a
| useful default for Linux and OS X systems as well as web
| applications.
|
| `keep_trailing_newline`
| Preserve the trailing newline when rendering templates.
| The default is ``False``, which causes a single newline,
| if present, to be stripped from the end of the template.
|
| .. versionadded:: 2.7
|
| `extensions`
| List of Jinja extensions to use. This can either be import paths
| as strings or extension classes. For more information have a
| look at :ref:`the extensions documentation <jinja-extensions>`.
|
| `optimized`
| should the optimizer be enabled? Default is ``True``.
|
| `undefined`
| :class:`Undefined` or a subclass of it that is used to represent
| undefined values in the template.
|
| `finalize`
| A callable that can be used to process the result of a variable
| expression before it is output. For example one can convert
| ``None`` implicitly into an empty string here.
|
| `autoescape`
| If set to ``True`` the XML/HTML autoescaping feature is enabled by
| default. For more details about autoescaping see
| :class:`~markupsafe.Markup`. As of Jinja 2.4 this can also
| be a callable that is passed the template name and has to
| return ``True`` or ``False`` depending on autoescape should be
| enabled by default.
|
| .. versionchanged:: 2.4
| `autoescape` can now be a function
|
| `loader`
| The template loader for this environment.
|
| `cache_size`
| The size of the cache. Per default this is ``400`` which means
| that if more than 400 templates are loaded the loader will clean
| out the least recently used template. If the cache size is set to
| ``0`` templates are recompiled all the time, if the cache size is
| ``-1`` the cache will not be cleaned.
|
| .. versionchanged:: 2.8
| The cache size was increased to 400 from a low 50.
|
| `auto_reload`
| Some loaders load templates from locations where the template
| sources may change (ie: file system or database). If
| ``auto_reload`` is set to ``True`` (default) every time a template is
| requested the loader checks if the source changed and if yes, it
| will reload the template. For higher performance it's possible to
| disable that.
|
| `bytecode_cache`
| If set to a bytecode cache object, this object will provide a
| cache for the internal Jinja bytecode so that templates don't
| have to be parsed if they were not changed.
|
| See :ref:`bytecode-cache` for more information.
|
| `enable_async`
| If set to true this enables async template execution which
| allows using async functions and generators.
|
| Methods defined here:
|
| __init__(self, block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, loader: Optional[ForwardRef('BaseLoader')] = None, cache_size: int = 400, auto_reload: bool = True, bytecode_cache: Optional[ForwardRef('BytecodeCache')] = None, enable_async: bool = False)
| Initialize self. See help(type(self)) for accurate signature.
|
| add_extension(self, extension: Union[str, Type[ForwardRef('Extension')]]) -> None
| Adds an extension after the environment was created.
|
| .. versionadded:: 2.5
|
| call_filter(self, name: str, value: Any, args: Optional[Sequence[Any]] = None, kwargs: Optional[Mapping[str, Any]] = None, context: Optional[jinja2.runtime.Context] = None, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Invoke a filter on a value the same way the compiler does.
|
| This might return a coroutine if the filter is running from an
| environment in async mode and the filter supports async
| execution. It's your responsibility to await this if needed.
|
| .. versionadded:: 2.7
|
| call_test(self, name: str, value: Any, args: Optional[Sequence[Any]] = None, kwargs: Optional[Mapping[str, Any]] = None, context: Optional[jinja2.runtime.Context] = None, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Invoke a test on a value the same way the compiler does.
|
| This might return a coroutine if the test is running from an
| environment in async mode and the test supports async execution.
| It's your responsibility to await this if needed.
|
| .. versionchanged:: 3.0
| Tests support ``@pass_context``, etc. decorators. Added
| the ``context`` and ``eval_ctx`` parameters.
|
| .. versionadded:: 2.7
|
| compile(self, source: Union[str, jinja2.nodes.Template], name: Optional[str] = None, filename: Optional[str] = None, raw: bool = False, defer_init: bool = False) -> Union[str, code]
| Compile a node or template source code. The `name` parameter is
| the load name of the template after it was joined using
| :meth:`join_path` if necessary, not the filename on the file system.
| the `filename` parameter is the estimated filename of the template on
| the file system. If the template came from a database or memory this
| can be omitted.
|
| The return value of this method is a python code object. If the `raw`
| parameter is `True` the return value will be a string with python
| code equivalent to the bytecode returned otherwise. This method is
| mainly used internally.
|
| `defer_init` is use internally to aid the module code generator. This
| causes the generated code to be able to import without the global
| environment variable to be set.
|
| .. versionadded:: 2.4
| `defer_init` parameter added.
|
| compile_expression(self, source: str, undefined_to_none: bool = True) -> 'TemplateExpression'
| A handy helper method that returns a callable that accepts keyword
| arguments that appear as variables in the expression. If called it
| returns the result of the expression.
|
| This is useful if applications want to use the same rules as Jinja
| in template "configuration files" or similar situations.
|
| Example usage:
|
| >>> env = Environment()
| >>> expr = env.compile_expression('foo == 42')
| >>> expr(foo=23)
| False
| >>> expr(foo=42)
| True
|
| Per default the return value is converted to `None` if the
| expression returns an undefined value. This can be changed
| by setting `undefined_to_none` to `False`.
|
| >>> env.compile_expression('var')() is None
| True
| >>> env.compile_expression('var', undefined_to_none=False)()
| Undefined
|
| .. versionadded:: 2.1
|
| compile_templates(self, target: Union[str, ForwardRef('os.PathLike[str]')], extensions: Optional[Collection[str]] = None, filter_func: Optional[Callable[[str], bool]] = None, zip: Optional[str] = 'deflated', log_function: Optional[Callable[[str], NoneType]] = None, ignore_errors: bool = True) -> None
| Finds all the templates the loader can find, compiles them
| and stores them in `target`. If `zip` is `None`, instead of in a
| zipfile, the templates will be stored in a directory.
| By default a deflate zip algorithm is used. To switch to
| the stored algorithm, `zip` can be set to ``'stored'``.
|
| `extensions` and `filter_func` are passed to :meth:`list_templates`.
| Each template returned will be compiled to the target folder or
| zipfile.
|
| By default template compilation errors are ignored. In case a
| log function is provided, errors are logged. If you want template
| syntax errors to abort the compilation you can set `ignore_errors`
| to `False` and you will get an exception on syntax errors.
|
| .. versionadded:: 2.4
|
| extend(self, **attributes: Any) -> None
| Add the items to the instance of the environment if they do not exist
| yet. This is used by :ref:`extensions <writing-extensions>` to register
| callbacks and configuration values without breaking inheritance.
|
| from_string(self, source: Union[str, jinja2.nodes.Template], globals: Optional[MutableMapping[str, Any]] = None, template_class: Optional[Type[ForwardRef('Template')]] = None) -> 'Template'
| Load a template from a source string without using
| :attr:`loader`.
|
| :param source: Jinja source to compile into a template.
| :param globals: Extend the environment :attr:`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.
| :param template_class: Return an instance of this
| :class:`Template` class.
|
| get_or_select_template(self, template_name_or_list: Union[str, ForwardRef('Template'), List[Union[str, ForwardRef('Template')]]], parent: Optional[str] = None, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Use :meth:`select_template` if an iterable of template names
| is given, or :meth:`get_template` if one name is given.
|
| .. versionadded:: 2.3
|
| get_template(self, name: Union[str, ForwardRef('Template')], parent: Optional[str] = None, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Load a template by name with :attr:`loader` and return a
| :class:`Template`. If the template does not exist a
| :exc:`TemplateNotFound` exception is raised.
|
| :param name: Name of the template to load. When loading
| templates from the filesystem, "/" is used as the path
| separator, even on Windows.
| :param parent: The name of the parent template importing this
| template. :meth:`join_path` can be used to implement name
| transformations with this.
| :param globals: Extend the environment :attr:`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.
|
| .. versionchanged:: 3.0
| If a template is loaded from cache, ``globals`` will update
| the template's globals instead of ignoring the new values.
|
| .. versionchanged:: 2.4
| If ``name`` is a :class:`Template` object it is returned
| unchanged.
|
| getattr(self, obj: Any, attribute: str) -> Any
| Get an item or attribute of an object but prefer the attribute.
| Unlike :meth:`getitem` the attribute *must* be a string.
|
| getitem(self, obj: Any, argument: Union[str, Any]) -> Union[Any, jinja2.runtime.Undefined]
| Get an item or attribute of an object but prefer the item.
|
| handle_exception(self, source: Optional[str] = None) -> 'te.NoReturn'
| Exception handling helper. This is used internally to either raise
| rewritten exceptions or return a rendered traceback for the template.
|
| iter_extensions(self) -> Iterator[ForwardRef('Extension')]
| Iterates over the extensions by priority.
|
| join_path(self, template: str, parent: str) -> str
| Join a template with the parent. By default all the lookups are
| relative to the loader root so this method returns the `template`
| parameter unchanged, but if the paths should be relative to the
| parent template, this function can be used to calculate the real
| template name.
|
| Subclasses may override this method and implement template path
| joining here.
|
| lex(self, source: str, name: Optional[str] = None, filename: Optional[str] = None) -> Iterator[Tuple[int, str, str]]
| Lex the given sourcecode and return a generator that yields
| tokens as tuples in the form ``(lineno, token_type, value)``.
| This can be useful for :ref:`extension development <writing-extensions>`
| and debugging templates.
|
| This does not perform preprocessing. If you want the preprocessing
| of the extensions to be applied you have to filter source through
| the :meth:`preprocess` method.
|
| list_templates(self, extensions: Optional[Collection[str]] = None, filter_func: Optional[Callable[[str], bool]] = None) -> List[str]
| Returns a list of templates for this environment. This requires
| that the loader supports the loader's
| :meth:`~BaseLoader.list_templates` method.
|
| If there are other files in the template folder besides the
| actual templates, the returned list can be filtered. There are two
| ways: either `extensions` is set to a list of file extensions for
| templates, or a `filter_func` can be provided which is a callable that
| is passed a template name and should return `True` if it should end up
| in the result list.
|
| If the loader does not support that, a :exc:`TypeError` is raised.
|
| .. versionadded:: 2.4
|
| make_globals(self, d: Optional[MutableMapping[str, Any]]) -> MutableMapping[str, Any]
| Make the globals map for a template. Any given template
| globals overlay the environment :attr:`globals`.
|
| Returns a :class:`collections.ChainMap`. This allows any changes
| to a template's globals to only affect that template, while
| changes to the environment's globals are still reflected.
| However, avoid modifying any globals after a template is loaded.
|
| :param d: Dict of template-specific globals.
|
| .. versionchanged:: 3.0
| Use :class:`collections.ChainMap` to always prevent mutating
| environment globals.
|
| overlay(self, block_start_string: str = missing, block_end_string: str = missing, variable_start_string: str = missing, variable_end_string: str = missing, comment_start_string: str = missing, comment_end_string: str = missing, line_statement_prefix: Optional[str] = missing, line_comment_prefix: Optional[str] = missing, trim_blocks: bool = missing, lstrip_blocks: bool = missing, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = missing, keep_trailing_newline: bool = missing, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = missing, optimized: bool = missing, undefined: Type[jinja2.runtime.Undefined] = missing, finalize: Optional[Callable[..., Any]] = missing, autoescape: Union[bool, Callable[[Optional[str]], bool]] = missing, loader: Optional[ForwardRef('BaseLoader')] = missing, cache_size: int = missing, auto_reload: bool = missing, bytecode_cache: Optional[ForwardRef('BytecodeCache')] = missing, enable_async: bool = False) -> 'Environment'
| Create 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.
|
| 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.
|
| .. versionchanged:: 3.1.2
| Added the ``newline_sequence``,, ``keep_trailing_newline``,
| and ``enable_async`` parameters to match ``__init__``.
|
| parse(self, source: str, name: Optional[str] = None, filename: Optional[str] = None) -> jinja2.nodes.Template
| Parse the sourcecode and return the abstract syntax tree. This
| tree of nodes is used by the compiler to convert the template into
| executable source- or bytecode. This is useful for debugging or to
| extract information from templates.
|
| If you are :ref:`developing Jinja extensions <writing-extensions>`
| this gives you a good overview of the node tree generated.
|
| preprocess(self, source: str, name: Optional[str] = None, filename: Optional[str] = None) -> str
| Preprocesses the source with all extensions. This is automatically
| called for all parsing and compiling methods but *not* for :meth:`lex`
| because there you usually only want the actual source tokenized.
|
| select_template(self, names: Iterable[Union[str, ForwardRef('Template')]], parent: Optional[str] = None, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Like :meth:`get_template`, but tries loading multiple names.
| If none of the names can be loaded a :exc:`TemplatesNotFound`
| exception is raised.
|
| :param names: List of template names to try loading in order.
| :param parent: The name of the parent template importing this
| template. :meth:`join_path` can be used to implement name
| transformations with this.
| :param globals: Extend the environment :attr:`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.
|
| .. versionchanged:: 3.0
| If a template is loaded from cache, ``globals`` will update
| the template's globals instead of ignoring the new values.
|
| .. versionchanged:: 2.11
| If ``names`` is :class:`Undefined`, an :exc:`UndefinedError`
| is raised instead. If no templates were found and ``names``
| contains :class:`Undefined`, the message is more helpful.
|
| .. versionchanged:: 2.4
| If ``names`` contains a :class:`Template` object it is
| returned unchanged.
|
| .. versionadded:: 2.3
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| concat = join(iterable, /) method of builtins.str instance
| Concatenate any number of strings.
|
| The string whose method is called is inserted in between each given string.
| The result is returned as a new string.
|
| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| lexer
| The lexer for this environment.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'code_generator_class': typing.Type[ForwardRef('Cod...
|
| code_generator_class = <class 'jinja2.compiler.CodeGenerator'>
|
| context_class = <class 'jinja2.runtime.Context'>
| The template context holds the variables of a template. It stores the
| values passed to the template and also the names the template exports.
| Creating instances is neither supported nor useful as it's created
| automatically at various stages of the template evaluation and should not
| be created by hand.
|
| The context is immutable. Modifications on :attr:`parent` **must not**
| happen and modifications on :attr:`vars` are allowed from generated
| template code only. Template filters and global functions marked as
| :func:`pass_context` get the active context passed as first argument
| and are allowed to access the context read-only.
|
| The template context supports read only dict operations (`get`,
| `keys`, `values`, `items`, `iterkeys`, `itervalues`, `iteritems`,
| `__getitem__`, `__contains__`). Additionally there is a :meth:`resolve`
| method that doesn't fail with a `KeyError` but returns an
| :class:`Undefined` object for missing variables.
|
|
| linked_to = None
|
| overlayed = False
|
| sandboxed = False
|
| shared = False
|
| template_class = <class 'jinja2.environment.Template'>
| A compiled template that can be rendered.
|
| Use the methods on :class:`Environment` to create or load templates.
| The environment is used to configure how templates are compiled and
| behave.
|
| It is also possible to create a template object directly. This is
| not usually recommended. The constructor takes most of the same
| arguments as :class:`Environment`. All templates created with the
| same environment arguments share the same ephemeral ``Environment``
| instance behind the scenes.
|
| A template object should be considered immutable. Modifications on
| the object are not supported.
jinja2.FileSystemBytecodeCache
Python Library Documentation: class FileSystemBytecodeCache in module jinja2.bccache
class FileSystemBytecodeCache(BytecodeCache)
| FileSystemBytecodeCache(directory: Optional[str] = None, pattern: str = '__jinja2_%s.cache') -> None
|
| A bytecode cache that stores bytecode on the filesystem. It accepts
| two arguments: The directory where the cache items are stored and a
| pattern string that is used to build the filename.
|
| If no directory is specified a default cache directory is selected. On
| Windows the user's temp directory is used, on UNIX systems a directory
| is created for the user in the system temp directory.
|
| The pattern can be used to have multiple separate caches operate on the
| same directory. The default pattern is ``'__jinja2_%s.cache'``. ``%s``
| is replaced with the cache key.
|
| >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
|
| This bytecode cache supports clearing of the cache using the clear method.
|
| Method resolution order:
| FileSystemBytecodeCache
| BytecodeCache
| builtins.object
|
| Methods defined here:
|
| __init__(self, directory: Optional[str] = None, pattern: str = '__jinja2_%s.cache') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| clear(self) -> None
| Clears the cache. This method is not used by Jinja but should be
| implemented to allow applications to clear the bytecode cache used
| by a particular environment.
|
| dump_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to write the bytecode
| from a bucket back to the cache. If it unable to do so it must not
| fail silently but raise an exception.
|
| load_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to load bytecode into a
| bucket. If they are not able to find code in the cache for the
| bucket, it must not do anything.
|
| ----------------------------------------------------------------------
| Methods inherited from BytecodeCache:
|
| get_bucket(self, environment: 'Environment', name: str, filename: Optional[str], source: str) -> jinja2.bccache.Bucket
| Return a cache bucket for the given template. All arguments are
| mandatory but filename may be `None`.
|
| get_cache_key(self, name: str, filename: Optional[str] = None) -> str
| Returns the unique hash key for this template name.
|
| get_source_checksum(self, source: str) -> str
| Returns a checksum for the source.
|
| set_bucket(self, bucket: jinja2.bccache.Bucket) -> None
| Put the bucket into the cache.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BytecodeCache:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
jinja2.FileSystemLoader
Python Library Documentation: class FileSystemLoader in module jinja2.loaders
class FileSystemLoader(BaseLoader)
| FileSystemLoader(searchpath: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]], encoding: str = 'utf-8', followlinks: bool = False) -> None
|
| Load templates from a directory in the file system.
|
| The path can be relative or absolute. Relative paths are relative to
| the current working directory.
|
| .. code-block:: python
|
| loader = FileSystemLoader("templates")
|
| A list of paths can be given. The directories will be searched in
| order, stopping at the first matching template.
|
| .. code-block:: python
|
| loader = FileSystemLoader(["/override/templates", "/default/templates"])
|
| :param searchpath: A path, or list of paths, to the directory that
| contains the templates.
| :param encoding: Use this encoding to read the text from template
| files.
| :param followlinks: Follow symbolic links in the path.
|
| .. versionchanged:: 2.8
| Added the ``followlinks`` parameter.
|
| Method resolution order:
| FileSystemLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, searchpath: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]], encoding: str = 'utf-8', followlinks: bool = False) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, str, Callable[[], bool]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
jinja2.FunctionLoader
Python Library Documentation: class FunctionLoader in module jinja2.loaders class FunctionLoader(BaseLoader) | FunctionLoader(load_func: Callable[[str], Union[str, Tuple[str, Optional[str], Optional[Callable[[], bool]]], NoneType]]) -> None | | A loader that is passed a function which does the loading. The | function receives the name of the template and has to return either | a string with the template source, a tuple in the form ``(source, | filename, uptodatefunc)`` or `None` if the template does not exist. | | >>> def load_template(name): | ... if name == 'index.html': | ... return '...' | ... | >>> loader = FunctionLoader(load_template) | | The `uptodatefunc` is a function that is called if autoreload is enabled | and has to return `True` if the template is still up to date. For more | details have a look at :meth:`BaseLoader.get_source` which has the same | return value. | | Method resolution order: | FunctionLoader | BaseLoader | builtins.object | | Methods defined here: | | __init__(self, load_func: Callable[[str], Union[str, Tuple[str, Optional[str], Optional[Callable[[], bool]]], NoneType]]) -> None | Initialize self. See help(type(self)) for accurate signature. | | get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]] | Get the template source, filename and reload helper for a template. | It's passed the environment and template name and has to return a | tuple in the form ``(source, filename, uptodate)`` or raise a | `TemplateNotFound` error if it can't locate the template. | | The source part of the returned tuple must be the source of the | template as a string. The filename should be the name of the | file on the filesystem if it was loaded from there, otherwise | ``None``. The filename is used by Python for the tracebacks | if no loader extension is used. | | The last item in the tuple is the `uptodate` function. If auto | reloading is enabled it's always called to check if the template | changed. No arguments are passed so the function must store the | old state somewhere (for example in a closure). If it returns `False` | the template will be reloaded. | | ---------------------------------------------------------------------- | Methods inherited from BaseLoader: | | list_templates(self) -> List[str] | Iterates over all templates. If the loader does not support that | it should raise a :exc:`TypeError` which is the default behavior. | | load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template' | Loads a template. This method looks up the template in the cache | or loads one by calling :meth:`get_source`. Subclasses should not | override this method as loaders working on collections of other | loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`) | will not call this method but `get_source` directly. | | ---------------------------------------------------------------------- | Data descriptors inherited from BaseLoader: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Data and other attributes inherited from BaseLoader: | | has_source_access = True
jinja2.MemcachedBytecodeCache
Python Library Documentation: class MemcachedBytecodeCache in module jinja2.bccache class MemcachedBytecodeCache(BytecodeCache) | MemcachedBytecodeCache(client: '_MemcachedClient', prefix: str = 'jinja2/bytecode/', timeout: Optional[int] = None, ignore_memcache_errors: bool = True) | | This class implements a bytecode cache that uses a memcache cache for | storing the information. It does not enforce a specific memcache library | (tummy's memcache or cmemcache) but will accept any class that provides | the minimal interface required. | | Libraries compatible with this class: | | - `cachelib <https://github.com/pallets/cachelib>`_ | - `python-memcached <https://pypi.org/project/python-memcached/>`_ | | (Unfortunately the django cache interface is not compatible because it | does not support storing binary data, only text. You can however pass | the underlying cache client to the bytecode cache which is available | as `django.core.cache.cache._client`.) | | The minimal interface for the client passed to the constructor is this: | | .. class:: MinimalClientInterface | | .. method:: set(key, value[, timeout]) | | Stores the bytecode in the cache. `value` is a string and | `timeout` the timeout of the key. If timeout is not provided | a default timeout or no timeout should be assumed, if it's | provided it's an integer with the number of seconds the cache | item should exist. | | .. method:: get(key) | | Returns the value for the cache key. If the item does not | exist in the cache the return value must be `None`. | | The other arguments to the constructor are the prefix for all keys that | is added before the actual cache key and the timeout for the bytecode in | the cache system. We recommend a high (or no) timeout. | | This bytecode cache does not support clearing of used items in the cache. | The clear method is a no-operation function. | | .. versionadded:: 2.7 | Added support for ignoring memcache errors through the | `ignore_memcache_errors` parameter. | | Method resolution order: | MemcachedBytecodeCache | BytecodeCache | builtins.object | | Methods defined here: | | __init__(self, client: '_MemcachedClient', prefix: str = 'jinja2/bytecode/', timeout: Optional[int] = None, ignore_memcache_errors: bool = True) | Initialize self. See help(type(self)) for accurate signature. | | dump_bytecode(self, bucket: jinja2.bccache.Bucket) -> None | Subclasses have to override this method to write the bytecode | from a bucket back to the cache. If it unable to do so it must not | fail silently but raise an exception. | | load_bytecode(self, bucket: jinja2.bccache.Bucket) -> None | Subclasses have to override this method to load bytecode into a | bucket. If they are not able to find code in the cache for the | bucket, it must not do anything. | | ---------------------------------------------------------------------- | Methods inherited from BytecodeCache: | | clear(self) -> None | Clears the cache. This method is not used by Jinja but should be | implemented to allow applications to clear the bytecode cache used | by a particular environment. | | get_bucket(self, environment: 'Environment', name: str, filename: Optional[str], source: str) -> jinja2.bccache.Bucket | Return a cache bucket for the given template. All arguments are | mandatory but filename may be `None`. | | get_cache_key(self, name: str, filename: Optional[str] = None) -> str | Returns the unique hash key for this template name. | | get_source_checksum(self, source: str) -> str | Returns a checksum for the source. | | set_bucket(self, bucket: jinja2.bccache.Bucket) -> None | Put the bucket into the cache. | | ---------------------------------------------------------------------- | Data descriptors inherited from BytecodeCache: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
jinja2.ModuleLoader
Python Library Documentation: class ModuleLoader in module jinja2.loaders
class ModuleLoader(BaseLoader)
| ModuleLoader(path: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]]) -> None
|
| This loader loads templates from precompiled templates.
|
| Example usage:
|
| >>> loader = ChoiceLoader([
| ... ModuleLoader('/path/to/compiled/templates'),
| ... FileSystemLoader('/path/to/templates')
| ... ])
|
| Templates can be precompiled with :meth:`Environment.compile_templates`.
|
| Method resolution order:
| ModuleLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, path: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| get_module_filename(name: str) -> str
|
| get_template_key(name: str) -> str
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_source_access = False
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
jinja2.PackageLoader
Python Library Documentation: class PackageLoader in module jinja2.loaders
class PackageLoader(BaseLoader)
| PackageLoader(package_name: str, package_path: 'str' = 'templates', encoding: str = 'utf-8') -> None
|
| Load templates from a directory in a Python package.
|
| :param package_name: Import name of the package that contains the
| template directory.
| :param package_path: Directory within the imported package that
| contains the templates.
| :param encoding: Encoding of template files.
|
| The following example looks up templates in the ``pages`` directory
| within the ``project.ui`` package.
|
| .. code-block:: python
|
| loader = PackageLoader("project.ui", "pages")
|
| Only packages installed as directories (standard pip behavior) or
| zip/egg files (less common) are supported. The Python API for
| introspecting data in packages is too limited to support other
| installation methods the way this loader requires.
|
| There is limited support for :pep:`420` namespace packages. The
| template directory is assumed to only be in one namespace
| contributor. Zip files contributing to a namespace are not
| supported.
|
| .. versionchanged:: 3.0
| No longer uses ``setuptools`` as a dependency.
|
| .. versionchanged:: 3.0
| Limited PEP 420 namespace package support.
|
| Method resolution order:
| PackageLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, package_name: str, package_path: 'str' = 'templates', encoding: str = 'utf-8') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, str, Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
jinja2.PrefixLoader
Python Library Documentation: class PrefixLoader in module jinja2.loaders
class PrefixLoader(BaseLoader)
| PrefixLoader(mapping: Mapping[str, jinja2.loaders.BaseLoader], delimiter: str = '/') -> None
|
| A loader that is passed a dict of loaders where each loader is bound
| to a prefix. The prefix is delimited from the template by a slash per
| default, which can be changed by setting the `delimiter` argument to
| something else::
|
| loader = PrefixLoader({
| 'app1': PackageLoader('mypackage.app1'),
| 'app2': PackageLoader('mypackage.app2')
| })
|
| By loading ``'app1/index.html'`` the file from the app1 package is loaded,
| by loading ``'app2/index.html'`` the file from the second.
|
| Method resolution order:
| PrefixLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, mapping: Mapping[str, jinja2.loaders.BaseLoader], delimiter: str = '/') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_loader(self, template: str) -> Tuple[jinja2.loaders.BaseLoader, str]
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
jinja2.StrictUndefined
Python Library Documentation: class StrictUndefined in module jinja2.runtime class StrictUndefined(Undefined) | StrictUndefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None | | An undefined that barks on print and iteration as well as boolean | tests and all kinds of comparisons. In other words: you can do nothing | with it except checking if it's defined using the `defined` test. | | >>> foo = StrictUndefined(name='foo') | >>> str(foo) | Traceback (most recent call last): | ... | jinja2.exceptions.UndefinedError: 'foo' is undefined | >>> not foo | Traceback (most recent call last): | ... | jinja2.exceptions.UndefinedError: 'foo' is undefined | >>> foo + 42 | Traceback (most recent call last): | ... | jinja2.exceptions.UndefinedError: 'foo' is undefined | | Method resolution order: | StrictUndefined | Undefined | builtins.object | | Methods defined here: | | __bool__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __contains__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __eq__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __hash__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __iter__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __len__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __ne__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __str__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | ---------------------------------------------------------------------- | Methods inherited from Undefined: | | __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | async __aiter__(self) -> AsyncIterator[Any] | | __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __getattr__(self, name: str) -> Any | | __getitem__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None | Initialize self. See help(type(self)) for accurate signature. | | __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __repr__(self) -> str | Return repr(self). | | __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
jinja2.Template
Python Library Documentation: class Template in module jinja2.environment
class Template(builtins.object)
| Template(source: Union[str, jinja2.nodes.Template], block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, enable_async: bool = False) -> Any
|
| A compiled template that can be rendered.
|
| Use the methods on :class:`Environment` to create or load templates.
| The environment is used to configure how templates are compiled and
| behave.
|
| It is also possible to create a template object directly. This is
| not usually recommended. The constructor takes most of the same
| arguments as :class:`Environment`. All templates created with the
| same environment arguments share the same ephemeral ``Environment``
| instance behind the scenes.
|
| A template object should be considered immutable. Modifications on
| the object are not supported.
|
| Methods defined here:
|
| __repr__(self) -> str
| Return repr(self).
|
| generate(self, *args: Any, **kwargs: Any) -> Iterator[str]
| For very large templates it can be useful to not render the whole
| template at once but evaluate each statement after another and yield
| piece for piece. This method basically does exactly that and returns
| a generator that yields one item after another as strings.
|
| It accepts the same arguments as :meth:`render`.
|
| async generate_async(self, *args: Any, **kwargs: Any) -> AsyncIterator[str]
| An async version of :meth:`generate`. Works very similarly but
| returns an async iterator instead.
|
| get_corresponding_lineno(self, lineno: int) -> int
| Return the source line number of a line number in the
| generated bytecode as they are not in sync.
|
| make_module(self, vars: Optional[Dict[str, Any]] = None, shared: bool = False, locals: Optional[Mapping[str, Any]] = None) -> 'TemplateModule'
| This method works like the :attr:`module` attribute when called
| without arguments but it will evaluate the template on every call
| rather than caching it. It's also possible to provide
| a dict which is then used as context. The arguments are the same
| as for the :meth:`new_context` method.
|
| async make_module_async(self, vars: Optional[Dict[str, Any]] = None, shared: bool = False, locals: Optional[Mapping[str, Any]] = None) -> 'TemplateModule'
| As template module creation can invoke template code for
| asynchronous executions this method must be used instead of the
| normal :meth:`make_module` one. Likewise the module attribute
| becomes unavailable in async mode.
|
| new_context(self, vars: Optional[Dict[str, Any]] = None, shared: bool = False, locals: Optional[Mapping[str, Any]] = None) -> jinja2.runtime.Context
| Create a new :class:`Context` for this template. The vars
| provided will be passed to the template. Per default the globals
| are added to the context. If shared is set to `True` the data
| is passed as is to the context without adding the globals.
|
| `locals` can be a dict of local variables for internal usage.
|
| render(self, *args: Any, **kwargs: Any) -> str
| This method accepts the same arguments as the `dict` constructor:
| A dict, a dict subclass or some keyword arguments. If no arguments
| are given the context will be empty. These two calls do the same::
|
| template.render(knights='that say nih')
| template.render({'knights': 'that say nih'})
|
| This will return the rendered template as a string.
|
| async render_async(self, *args: Any, **kwargs: Any) -> str
| This works similar to :meth:`render` but returns a coroutine
| that when awaited returns the entire rendered template string. This
| requires the async feature to be enabled.
|
| Example usage::
|
| await template.render_async(knights='that say nih; asynchronously')
|
| stream(self, *args: Any, **kwargs: Any) -> 'TemplateStream'
| Works exactly like :meth:`generate` but returns a
| :class:`TemplateStream`.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_code(environment: jinja2.environment.Environment, code: code, globals: MutableMapping[str, Any], uptodate: Optional[Callable[[], bool]] = None) -> 'Template'
| Creates a template object from compiled code and the globals. This
| is used by the loaders and environment to create a template object.
|
| from_module_dict(environment: jinja2.environment.Environment, module_dict: MutableMapping[str, Any], globals: MutableMapping[str, Any]) -> 'Template'
| Creates a template object from a module. This is used by the
| module loader to create a template object.
|
| .. versionadded:: 2.4
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, source: Union[str, jinja2.nodes.Template], block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, enable_async: bool = False) -> Any
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| debug_info
| The debug info mapping.
|
| is_up_to_date
| If this variable is `False` there is a newer version available.
|
| module
| The template as module. This is used for imports in the
| template runtime but is also useful if one wants to access
| exported template variables from the Python layer:
|
| >>> t = Template('{% macro foo() %}42{% endmacro %}23')
| >>> str(t.module)
| '23'
| >>> t.module.foo() == u'42'
| True
|
| This attribute is not available if async mode is enabled.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_debug_info': <class 'str'>, '_module': typing.Opt...
|
| environment_class = <class 'jinja2.environment.Environment'>
| The core component of Jinja is the `Environment`. It contains
| important shared variables like configuration, filters, tests,
| globals and others. Instances of this class may be modified if
| they are not shared and if no template was loaded so far.
| Modifications on environments after the first template was loaded
| will lead to surprising effects and undefined behavior.
|
| Here are the possible initialization parameters:
|
| `block_start_string`
| The string marking the beginning of a block. Defaults to ``'{%'``.
|
| `block_end_string`
| The string marking the end of a block. Defaults to ``'%}'``.
|
| `variable_start_string`
| The string marking the beginning of a print statement.
| Defaults to ``'{{'``.
|
| `variable_end_string`
| The string marking the end of a print statement. Defaults to
| ``'}}'``.
|
| `comment_start_string`
| The string marking the beginning of a comment. Defaults to ``'{#'``.
|
| `comment_end_string`
| The string marking the end of a comment. Defaults to ``'#}'``.
|
| `line_statement_prefix`
| If given and a string, this will be used as prefix for line based
| statements. See also :ref:`line-statements`.
|
| `line_comment_prefix`
| If given and a string, this will be used as prefix for line based
| comments. See also :ref:`line-statements`.
|
| .. versionadded:: 2.2
|
| `trim_blocks`
| If this is set to ``True`` the first newline after a block is
| removed (block, not variable tag!). Defaults to `False`.
|
| `lstrip_blocks`
| If this is set to ``True`` leading spaces and tabs are stripped
| from the start of a line to a block. Defaults to `False`.
|
| `newline_sequence`
| The sequence that starts a newline. Must be one of ``'\r'``,
| ``'\n'`` or ``'\r\n'``. The default is ``'\n'`` which is a
| useful default for Linux and OS X systems as well as web
| applications.
|
| `keep_trailing_newline`
| Preserve the trailing newline when rendering templates.
| The default is ``False``, which causes a single newline,
| if present, to be stripped from the end of the template.
|
| .. versionadded:: 2.7
|
| `extensions`
| List of Jinja extensions to use. This can either be import paths
| as strings or extension classes. For more information have a
| look at :ref:`the extensions documentation <jinja-extensions>`.
|
| `optimized`
| should the optimizer be enabled? Default is ``True``.
|
| `undefined`
| :class:`Undefined` or a subclass of it that is used to represent
| undefined values in the template.
|
| `finalize`
| A callable that can be used to process the result of a variable
| expression before it is output. For example one can convert
| ``None`` implicitly into an empty string here.
|
| `autoescape`
| If set to ``True`` the XML/HTML autoescaping feature is enabled by
| default. For more details about autoescaping see
| :class:`~markupsafe.Markup`. As of Jinja 2.4 this can also
| be a callable that is passed the template name and has to
| return ``True`` or ``False`` depending on autoescape should be
| enabled by default.
|
| .. versionchanged:: 2.4
| `autoescape` can now be a function
|
| `loader`
| The template loader for this environment.
|
| `cache_size`
| The size of the cache. Per default this is ``400`` which means
| that if more than 400 templates are loaded the loader will clean
| out the least recently used template. If the cache size is set to
| ``0`` templates are recompiled all the time, if the cache size is
| ``-1`` the cache will not be cleaned.
|
| .. versionchanged:: 2.8
| The cache size was increased to 400 from a low 50.
|
| `auto_reload`
| Some loaders load templates from locations where the template
| sources may change (ie: file system or database). If
| ``auto_reload`` is set to ``True`` (default) every time a template is
| requested the loader checks if the source changed and if yes, it
| will reload the template. For higher performance it's possible to
| disable that.
|
| `bytecode_cache`
| If set to a bytecode cache object, this object will provide a
| cache for the internal Jinja bytecode so that templates don't
| have to be parsed if they were not changed.
|
| See :ref:`bytecode-cache` for more information.
|
| `enable_async`
| If set to true this enables async template execution which
| allows using async functions and generators.
jinja2.TemplateAssertionError
Python Library Documentation: class TemplateAssertionError in module jinja2.exceptions class TemplateAssertionError(TemplateSyntaxError) | TemplateAssertionError(message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None | | Like a template syntax error, but covers cases where something in the | template caused an error at compile time that wasn't necessarily caused | by a syntax error. However it's a direct subclass of | :exc:`TemplateSyntaxError` and has the same attributes. | | Method resolution order: | TemplateAssertionError | TemplateSyntaxError | TemplateError | builtins.Exception | builtins.BaseException | builtins.object | | Methods inherited from TemplateSyntaxError: | | __init__(self, message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None | Initialize self. See help(type(self)) for accurate signature. | | __reduce__(self) | Helper for pickle. | | __str__(self) -> str | Return str(self). | | ---------------------------------------------------------------------- | Readonly properties inherited from TemplateError: | | message | | ---------------------------------------------------------------------- | Data descriptors inherited from TemplateError: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
jinja2.TemplateError
Python Library Documentation: class TemplateError in module jinja2.exceptions class TemplateError(builtins.Exception) | TemplateError(message: Optional[str] = None) -> None | | Baseclass for all template errors. | | Method resolution order: | TemplateError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message: Optional[str] = None) -> None | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Readonly properties defined here: | | message | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
jinja2.TemplateNotFound
Python Library Documentation: class TemplateNotFound in module jinja2.exceptions
class TemplateNotFound(builtins.OSError, builtins.LookupError, TemplateError)
| TemplateNotFound(name: Union[str, ForwardRef('Undefined'), NoneType], message: Optional[str] = None) -> None
|
| Raised if a template does not exist.
|
| .. versionchanged:: 2.11
| If the given name is :class:`Undefined` and no message was
| provided, an :exc:`UndefinedError` is raised.
|
| Method resolution order:
| TemplateNotFound
| builtins.OSError
| builtins.LookupError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, name: Union[str, ForwardRef('Undefined'), NoneType], message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'message': typing.Optional[str]}
|
| message = None
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __reduce__(...)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.OSError:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
jinja2.TemplateRuntimeError
Python Library Documentation: class TemplateRuntimeError in module jinja2.exceptions
class TemplateRuntimeError(TemplateError)
| TemplateRuntimeError(message: Optional[str] = None) -> None
|
| A generic runtime error in the template engine. Under some situations
| Jinja may raise this exception.
|
| Method resolution order:
| TemplateRuntimeError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateError:
|
| __init__(self, message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
jinja2.TemplateSyntaxError
Python Library Documentation: class TemplateSyntaxError in module jinja2.exceptions
class TemplateSyntaxError(TemplateError)
| TemplateSyntaxError(message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None
|
| Raised to tell the user that there is a problem with the template.
|
| Method resolution order:
| TemplateSyntaxError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(self)
| Helper for pickle.
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
jinja2.TemplatesNotFound
Python Library Documentation: class TemplatesNotFound in module jinja2.exceptions
class TemplatesNotFound(TemplateNotFound)
| TemplatesNotFound(names: Sequence[Union[str, ForwardRef('Undefined')]] = (), message: Optional[str] = None) -> None
|
| Like :class:`TemplateNotFound` but raised if multiple templates
| are selected. This is a subclass of :class:`TemplateNotFound`
| exception, so just catching the base exception will catch both.
|
| .. versionchanged:: 2.11
| If a name in the list of names is :class:`Undefined`, a message
| about it being undefined is shown rather than the empty string.
|
| .. versionadded:: 2.2
|
| Method resolution order:
| TemplatesNotFound
| TemplateNotFound
| builtins.OSError
| builtins.LookupError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, names: Sequence[Union[str, ForwardRef('Undefined')]] = (), message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateNotFound:
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateNotFound:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TemplateNotFound:
|
| message = None
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __reduce__(...)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.OSError:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
jinja2.Undefined
Python Library Documentation: class Undefined in module jinja2.runtime class Undefined(builtins.object) | Undefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None | | The default undefined type. This undefined type can be printed and | iterated over, but every other access will raise an :exc:`UndefinedError`: | | >>> foo = Undefined(name='foo') | >>> str(foo) | '' | >>> not foo | True | >>> foo + 42 | Traceback (most recent call last): | ... | jinja2.exceptions.UndefinedError: 'foo' is undefined | | Methods defined here: | | __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | async __aiter__(self) -> AsyncIterator[Any] | | __bool__(self) -> bool | | __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __eq__(self, other: Any) -> bool | Return self==value. | | __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __getattr__(self, name: str) -> Any | | __getitem__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __hash__(self) -> int | Return hash(self). | | __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None | Initialize self. See help(type(self)) for accurate signature. | | __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __iter__(self) -> Iterator[Any] | | __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __len__(self) -> int | | __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __ne__(self, other: Any) -> bool | Return self!=value. | | __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __repr__(self) -> str | Return repr(self). | | __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __str__(self) -> str | Return str(self). | | __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn' | | __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
jinja2.UndefinedError
Python Library Documentation: class UndefinedError in module jinja2.exceptions
class UndefinedError(TemplateRuntimeError)
| UndefinedError(message: Optional[str] = None) -> None
|
| Raised if a template tries to operate on :class:`Undefined`.
|
| Method resolution order:
| UndefinedError
| TemplateRuntimeError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateError:
|
| __init__(self, message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
jinja2.async_utils
Python Library Documentation: module jinja2.async_utils in jinja2
NAME
jinja2.async_utils
FUNCTIONS
async_variant(normal_func)
async auto_aiter(iterable: 't.Union[t.AsyncIterable[V], t.Iterable[V]]') -> 't.AsyncIterator[V]'
async auto_await(value: Union[Awaitable[ForwardRef('V')], ForwardRef('V')]) -> 'V'
async auto_to_list(value: 't.Union[t.AsyncIterable[V], t.Iterable[V]]') -> List[ForwardRef('V')]
DATA
V = ~V
WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__do...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\async_utils.py
jinja2.bccache
Python Library Documentation: module jinja2.bccache in jinja2
NAME
jinja2.bccache
DESCRIPTION
The optional bytecode cache system. This is useful if you have very
complex template situations and the compilation of all those templates
slows down your application too much.
Situations where this is useful are often forking web applications that
are initialized on the first request.
CLASSES
builtins.object
Bucket
BytecodeCache
FileSystemBytecodeCache
MemcachedBytecodeCache
class Bucket(builtins.object)
| Bucket(environment: 'Environment', key: str, checksum: str) -> None
|
| Buckets are used to store the bytecode for one template. It's created
| and initialized by the bytecode cache and passed to the loading functions.
|
| The buckets get an internal checksum from the cache assigned and use this
| to automatically reject outdated cache material. Individual bytecode
| cache subclasses don't have to care about cache invalidation.
|
| Methods defined here:
|
| __init__(self, environment: 'Environment', key: str, checksum: str) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| bytecode_from_string(self, string: bytes) -> None
| Load bytecode from bytes.
|
| bytecode_to_string(self) -> bytes
| Return the bytecode as bytes.
|
| load_bytecode(self, f: <class 'BinaryIO'>) -> None
| Loads bytecode from a file or file like object.
|
| reset(self) -> None
| Resets the bucket (unloads the bytecode).
|
| write_bytecode(self, f: IO[bytes]) -> None
| Dump the bytecode into the file or file like object passed.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class BytecodeCache(builtins.object)
| To implement your own bytecode cache you have to subclass this class
| and override :meth:`load_bytecode` and :meth:`dump_bytecode`. Both of
| these methods are passed a :class:`~jinja2.bccache.Bucket`.
|
| A very basic bytecode cache that saves the bytecode on the file system::
|
| from os import path
|
| class MyCache(BytecodeCache):
|
| def __init__(self, directory):
| self.directory = directory
|
| def load_bytecode(self, bucket):
| filename = path.join(self.directory, bucket.key)
| if path.exists(filename):
| with open(filename, 'rb') as f:
| bucket.load_bytecode(f)
|
| def dump_bytecode(self, bucket):
| filename = path.join(self.directory, bucket.key)
| with open(filename, 'wb') as f:
| bucket.write_bytecode(f)
|
| A more advanced version of a filesystem based bytecode cache is part of
| Jinja.
|
| Methods defined here:
|
| clear(self) -> None
| Clears the cache. This method is not used by Jinja but should be
| implemented to allow applications to clear the bytecode cache used
| by a particular environment.
|
| dump_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to write the bytecode
| from a bucket back to the cache. If it unable to do so it must not
| fail silently but raise an exception.
|
| get_bucket(self, environment: 'Environment', name: str, filename: Optional[str], source: str) -> jinja2.bccache.Bucket
| Return a cache bucket for the given template. All arguments are
| mandatory but filename may be `None`.
|
| get_cache_key(self, name: str, filename: Optional[str] = None) -> str
| Returns the unique hash key for this template name.
|
| get_source_checksum(self, source: str) -> str
| Returns a checksum for the source.
|
| load_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to load bytecode into a
| bucket. If they are not able to find code in the cache for the
| bucket, it must not do anything.
|
| set_bucket(self, bucket: jinja2.bccache.Bucket) -> None
| Put the bucket into the cache.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class FileSystemBytecodeCache(BytecodeCache)
| FileSystemBytecodeCache(directory: Optional[str] = None, pattern: str = '__jinja2_%s.cache') -> None
|
| A bytecode cache that stores bytecode on the filesystem. It accepts
| two arguments: The directory where the cache items are stored and a
| pattern string that is used to build the filename.
|
| If no directory is specified a default cache directory is selected. On
| Windows the user's temp directory is used, on UNIX systems a directory
| is created for the user in the system temp directory.
|
| The pattern can be used to have multiple separate caches operate on the
| same directory. The default pattern is ``'__jinja2_%s.cache'``. ``%s``
| is replaced with the cache key.
|
| >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
|
| This bytecode cache supports clearing of the cache using the clear method.
|
| Method resolution order:
| FileSystemBytecodeCache
| BytecodeCache
| builtins.object
|
| Methods defined here:
|
| __init__(self, directory: Optional[str] = None, pattern: str = '__jinja2_%s.cache') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| clear(self) -> None
| Clears the cache. This method is not used by Jinja but should be
| implemented to allow applications to clear the bytecode cache used
| by a particular environment.
|
| dump_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to write the bytecode
| from a bucket back to the cache. If it unable to do so it must not
| fail silently but raise an exception.
|
| load_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to load bytecode into a
| bucket. If they are not able to find code in the cache for the
| bucket, it must not do anything.
|
| ----------------------------------------------------------------------
| Methods inherited from BytecodeCache:
|
| get_bucket(self, environment: 'Environment', name: str, filename: Optional[str], source: str) -> jinja2.bccache.Bucket
| Return a cache bucket for the given template. All arguments are
| mandatory but filename may be `None`.
|
| get_cache_key(self, name: str, filename: Optional[str] = None) -> str
| Returns the unique hash key for this template name.
|
| get_source_checksum(self, source: str) -> str
| Returns a checksum for the source.
|
| set_bucket(self, bucket: jinja2.bccache.Bucket) -> None
| Put the bucket into the cache.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BytecodeCache:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class MemcachedBytecodeCache(BytecodeCache)
| MemcachedBytecodeCache(client: '_MemcachedClient', prefix: str = 'jinja2/bytecode/', timeout: Optional[int] = None, ignore_memcache_errors: bool = True)
|
| This class implements a bytecode cache that uses a memcache cache for
| storing the information. It does not enforce a specific memcache library
| (tummy's memcache or cmemcache) but will accept any class that provides
| the minimal interface required.
|
| Libraries compatible with this class:
|
| - `cachelib <https://github.com/pallets/cachelib>`_
| - `python-memcached <https://pypi.org/project/python-memcached/>`_
|
| (Unfortunately the django cache interface is not compatible because it
| does not support storing binary data, only text. You can however pass
| the underlying cache client to the bytecode cache which is available
| as `django.core.cache.cache._client`.)
|
| The minimal interface for the client passed to the constructor is this:
|
| .. class:: MinimalClientInterface
|
| .. method:: set(key, value[, timeout])
|
| Stores the bytecode in the cache. `value` is a string and
| `timeout` the timeout of the key. If timeout is not provided
| a default timeout or no timeout should be assumed, if it's
| provided it's an integer with the number of seconds the cache
| item should exist.
|
| .. method:: get(key)
|
| Returns the value for the cache key. If the item does not
| exist in the cache the return value must be `None`.
|
| The other arguments to the constructor are the prefix for all keys that
| is added before the actual cache key and the timeout for the bytecode in
| the cache system. We recommend a high (or no) timeout.
|
| This bytecode cache does not support clearing of used items in the cache.
| The clear method is a no-operation function.
|
| .. versionadded:: 2.7
| Added support for ignoring memcache errors through the
| `ignore_memcache_errors` parameter.
|
| Method resolution order:
| MemcachedBytecodeCache
| BytecodeCache
| builtins.object
|
| Methods defined here:
|
| __init__(self, client: '_MemcachedClient', prefix: str = 'jinja2/bytecode/', timeout: Optional[int] = None, ignore_memcache_errors: bool = True)
| Initialize self. See help(type(self)) for accurate signature.
|
| dump_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to write the bytecode
| from a bucket back to the cache. If it unable to do so it must not
| fail silently but raise an exception.
|
| load_bytecode(self, bucket: jinja2.bccache.Bucket) -> None
| Subclasses have to override this method to load bytecode into a
| bucket. If they are not able to find code in the cache for the
| bucket, it must not do anything.
|
| ----------------------------------------------------------------------
| Methods inherited from BytecodeCache:
|
| clear(self) -> None
| Clears the cache. This method is not used by Jinja but should be
| implemented to allow applications to clear the bytecode cache used
| by a particular environment.
|
| get_bucket(self, environment: 'Environment', name: str, filename: Optional[str], source: str) -> jinja2.bccache.Bucket
| Return a cache bucket for the given template. All arguments are
| mandatory but filename may be `None`.
|
| get_cache_key(self, name: str, filename: Optional[str] = None) -> str
| Returns the unique hash key for this template name.
|
| get_source_checksum(self, source: str) -> str
| Returns a checksum for the source.
|
| set_bucket(self, bucket: jinja2.bccache.Bucket) -> None
| Put the bucket into the cache.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BytecodeCache:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
sha1 = openssl_sha1(string=b'', *, usedforsecurity=True)
Returns a sha1 hash object; optionally initialized with a string
DATA
bc_magic = b'j2\x80\x02K\x05.\x80\x02J\x0c\x00\x00\x03.'
bc_version = 5
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\bccache.py
jinja2.clear_caches
Python Library Documentation: function clear_caches in module jinja2.utils
clear_caches() -> None
Jinja keeps internal caches for environments and lexers. These are
used so that Jinja doesn't have to recreate environments and lexers all
the time. Normally you don't have to care about that but if you are
measuring memory consumption you may want to clean the caches.
jinja2.compiler
Python Library Documentation: module jinja2.compiler in jinja2
NAME
jinja2.compiler - Compiles nodes from the parser into Python code.
CLASSES
builtins.Exception(builtins.BaseException)
CompilerExit
builtins.RuntimeError(builtins.Exception)
VisitorExit
builtins.object
Frame
MacroRef
jinja2.visitor.NodeVisitor(builtins.object)
CodeGenerator
DependencyFinderVisitor
UndeclaredNameVisitor
class CodeGenerator(jinja2.visitor.NodeVisitor)
| CodeGenerator(environment: 'Environment', name: Optional[str], filename: Optional[str], stream: Optional[TextIO] = None, defer_init: bool = False, optimized: bool = True) -> None
|
| Method resolution order:
| CodeGenerator
| jinja2.visitor.NodeVisitor
| builtins.object
|
| Methods defined here:
|
| __init__(self, environment: 'Environment', name: Optional[str], filename: Optional[str], stream: Optional[TextIO] = None, defer_init: bool = False, optimized: bool = True) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| blockvisit(self, nodes: Iterable[jinja2.nodes.Node], frame: jinja2.compiler.Frame) -> None
| Visit a list of nodes as block in a frame. If the current frame
| is no buffer a dummy ``if 0: yield None`` is written automatically.
|
| buffer(self, frame: jinja2.compiler.Frame) -> None
| Enable buffering for the frame from that point onwards.
|
| choose_async(self, async_value: str = 'async ', sync_value: str = '') -> str
|
| derive_context(self, frame: jinja2.compiler.Frame) -> str
|
| dump_local_context(self, frame: jinja2.compiler.Frame) -> str
|
| end_write(self, frame: jinja2.compiler.Frame) -> None
| End the writing process started by `start_write`.
|
| enter_frame(self, frame: jinja2.compiler.Frame) -> None
|
| fail(self, msg: str, lineno: int) -> 'te.NoReturn'
| Fail with a :exc:`TemplateAssertionError`.
|
| func(self, name: str) -> str
|
| get_context_ref(self) -> str
|
| get_resolve_func(self) -> str
|
| indent(self) -> None
| Indent by one.
|
| leave_frame(self, frame: jinja2.compiler.Frame, with_python_scope: bool = False) -> None
|
| macro_body(self, node: Union[jinja2.nodes.Macro, jinja2.nodes.CallBlock], frame: jinja2.compiler.Frame) -> Tuple[jinja2.compiler.Frame, jinja2.compiler.MacroRef]
| Dump the function def of a macro or call block.
|
| macro_def(self, macro_ref: jinja2.compiler.MacroRef, frame: jinja2.compiler.Frame) -> None
| Dump the macro definition for the def created by macro_body.
|
| mark_parameter_stored(self, target: str) -> None
| Marks a parameter in the current parameter definitions as stored.
| This will skip the enforced undefined checks.
|
| newline(self, node: Optional[jinja2.nodes.Node] = None, extra: int = 0) -> None
| Add one or more newlines before the next write.
|
| outdent(self, step: int = 1) -> None
| Outdent by step.
|
| parameter_is_undeclared(self, target: str) -> bool
| Checks if a given target is an undeclared parameter.
|
| pop_assign_tracking(self, frame: jinja2.compiler.Frame) -> None
| Pops the topmost level for assignment tracking and updates the
| context variables if necessary.
|
| pop_context_reference(self) -> None
|
| pop_parameter_definitions(self) -> None
| Pops the current parameter definitions set.
|
| position(self, node: jinja2.nodes.Node) -> str
| Return a human readable position for the node.
|
| pull_dependencies(self, nodes: Iterable[jinja2.nodes.Node]) -> None
| Find all filter and test names used in the template and
| assign them to variables in the compiled namespace. Checking
| that the names are registered with the environment is done when
| compiling the Filter and Test nodes. If the node is in an If or
| CondExpr node, the check is done at runtime instead.
|
| .. versionchanged:: 3.0
| Filters and tests in If and CondExpr nodes are checked at
| runtime instead of compile time.
|
| push_assign_tracking(self) -> None
| Pushes a new layer for assignment tracking.
|
| push_context_reference(self, target: str) -> None
|
| push_parameter_definitions(self, frame: jinja2.compiler.Frame) -> None
| Pushes all parameter targets from the given frame into a local
| stack that permits tracking of yet to be assigned parameters. In
| particular this enables the optimization from `visit_Name` to skip
| undefined expressions for parameters in macros as macros can reference
| otherwise unbound parameters.
|
| return_buffer_contents(self, frame: jinja2.compiler.Frame, force_unescaped: bool = False) -> None
| Return the buffer contents of the frame.
|
| signature(self, node: Union[jinja2.nodes.Call, jinja2.nodes.Filter, jinja2.nodes.Test], frame: jinja2.compiler.Frame, extra_kwargs: Optional[Mapping[str, Any]] = None) -> None
| Writes a function call to the stream for the current node.
| A leading comma is added automatically. The extra keyword
| arguments may not include python keywords otherwise a syntax
| error could occur. The extra keyword arguments should be given
| as python dict.
|
| simple_write(self, s: str, frame: jinja2.compiler.Frame, node: Optional[jinja2.nodes.Node] = None) -> None
| Simple shortcut for start_write + write + end_write.
|
| start_write(self, frame: jinja2.compiler.Frame, node: Optional[jinja2.nodes.Node] = None) -> None
| Yield or write into the frame buffer.
|
| temporary_identifier(self) -> str
| Get a new unique identifier.
|
| visit_Add = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_And = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_Assign(self, node: jinja2.nodes.Assign, frame: jinja2.compiler.Frame) -> None
|
| visit_AssignBlock(self, node: jinja2.nodes.AssignBlock, frame: jinja2.compiler.Frame) -> None
|
| visit_Block(self, node: jinja2.nodes.Block, frame: jinja2.compiler.Frame) -> None
| Call a block and register it for the template.
|
| visit_Break(self, node: jinja2.nodes.Break, frame: jinja2.compiler.Frame) -> None
|
| visit_Call(self, node: jinja2.nodes.Call, frame: jinja2.compiler.Frame, forward_caller: bool = False) -> None
|
| visit_CallBlock(self, node: jinja2.nodes.CallBlock, frame: jinja2.compiler.Frame) -> None
|
| visit_Compare(self, node: jinja2.nodes.Compare, frame: jinja2.compiler.Frame) -> None
|
| visit_Concat(self, node: jinja2.nodes.Concat, frame: jinja2.compiler.Frame) -> None
|
| visit_CondExpr(self, node: jinja2.nodes.CondExpr, frame: jinja2.compiler.Frame) -> None
|
| visit_Const(self, node: jinja2.nodes.Const, frame: jinja2.compiler.Frame) -> None
|
| visit_ContextReference(self, node: jinja2.nodes.ContextReference, frame: jinja2.compiler.Frame) -> None
|
| visit_Continue(self, node: jinja2.nodes.Continue, frame: jinja2.compiler.Frame) -> None
|
| visit_DerivedContextReference(self, node: jinja2.nodes.DerivedContextReference, frame: jinja2.compiler.Frame) -> None
|
| visit_Dict(self, node: jinja2.nodes.Dict, frame: jinja2.compiler.Frame) -> None
|
| visit_Div = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_EnvironmentAttribute(self, node: jinja2.nodes.EnvironmentAttribute, frame: jinja2.compiler.Frame) -> None
|
| visit_EvalContextModifier(self, node: jinja2.nodes.EvalContextModifier, frame: jinja2.compiler.Frame) -> None
|
| visit_ExprStmt(self, node: jinja2.nodes.ExprStmt, frame: jinja2.compiler.Frame) -> None
|
| visit_Extends(self, node: jinja2.nodes.Extends, frame: jinja2.compiler.Frame) -> None
| Calls the extender.
|
| visit_ExtensionAttribute(self, node: jinja2.nodes.ExtensionAttribute, frame: jinja2.compiler.Frame) -> None
|
| visit_Filter(self, node: jinja2.nodes.Filter, frame: jinja2.compiler.Frame) -> None
|
| visit_FilterBlock(self, node: jinja2.nodes.FilterBlock, frame: jinja2.compiler.Frame) -> None
|
| visit_FloorDiv = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_For(self, node: jinja2.nodes.For, frame: jinja2.compiler.Frame) -> None
|
| visit_FromImport(self, node: jinja2.nodes.FromImport, frame: jinja2.compiler.Frame) -> None
| Visit named imports.
|
| visit_Getattr(self, node: jinja2.nodes.Getattr, frame: jinja2.compiler.Frame) -> None
|
| visit_Getitem(self, node: jinja2.nodes.Getitem, frame: jinja2.compiler.Frame) -> None
|
| visit_If(self, node: jinja2.nodes.If, frame: jinja2.compiler.Frame) -> None
|
| visit_Import(self, node: jinja2.nodes.Import, frame: jinja2.compiler.Frame) -> None
| Visit regular imports.
|
| visit_ImportedName(self, node: jinja2.nodes.ImportedName, frame: jinja2.compiler.Frame) -> None
|
| visit_Include(self, node: jinja2.nodes.Include, frame: jinja2.compiler.Frame) -> None
| Handles includes.
|
| visit_InternalName(self, node: jinja2.nodes.InternalName, frame: jinja2.compiler.Frame) -> None
|
| visit_Keyword(self, node: jinja2.nodes.Keyword, frame: jinja2.compiler.Frame) -> None
|
| visit_List(self, node: jinja2.nodes.List, frame: jinja2.compiler.Frame) -> None
|
| visit_Macro(self, node: jinja2.nodes.Macro, frame: jinja2.compiler.Frame) -> None
|
| visit_MarkSafe(self, node: jinja2.nodes.MarkSafe, frame: jinja2.compiler.Frame) -> None
|
| visit_MarkSafeIfAutoescape(self, node: jinja2.nodes.MarkSafeIfAutoescape, frame: jinja2.compiler.Frame) -> None
|
| visit_Mod = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_Mul = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_NSRef(self, node: jinja2.nodes.NSRef, frame: jinja2.compiler.Frame) -> None
|
| visit_Name(self, node: jinja2.nodes.Name, frame: jinja2.compiler.Frame) -> None
|
| visit_Neg = visitor(self: 'CodeGenerator', node: jinja2.nodes.UnaryExpr, frame: jinja2.compiler.Frame) -> None from _make_unop.<locals>
|
| visit_Not = visitor(self: 'CodeGenerator', node: jinja2.nodes.UnaryExpr, frame: jinja2.compiler.Frame) -> None from _make_unop.<locals>
|
| visit_Operand(self, node: jinja2.nodes.Operand, frame: jinja2.compiler.Frame) -> None
|
| visit_Or = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_Output(self, node: jinja2.nodes.Output, frame: jinja2.compiler.Frame) -> None
|
| visit_OverlayScope(self, node: jinja2.nodes.OverlayScope, frame: jinja2.compiler.Frame) -> None
|
| visit_Pos = visitor(self: 'CodeGenerator', node: jinja2.nodes.UnaryExpr, frame: jinja2.compiler.Frame) -> None from _make_unop.<locals>
|
| visit_Pow = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_Scope(self, node: jinja2.nodes.Scope, frame: jinja2.compiler.Frame) -> None
|
| visit_ScopedEvalContextModifier(self, node: jinja2.nodes.ScopedEvalContextModifier, frame: jinja2.compiler.Frame) -> None
|
| visit_Slice(self, node: jinja2.nodes.Slice, frame: jinja2.compiler.Frame) -> None
|
| visit_Sub = visitor(self: 'CodeGenerator', node: jinja2.nodes.BinExpr, frame: jinja2.compiler.Frame) -> None from _make_binop.<locals>
|
| visit_Template(self, node: jinja2.nodes.Template, frame: Optional[jinja2.compiler.Frame] = None) -> None
|
| visit_TemplateData(self, node: jinja2.nodes.TemplateData, frame: jinja2.compiler.Frame) -> None
|
| visit_Test(self, node: jinja2.nodes.Test, frame: jinja2.compiler.Frame) -> None
|
| visit_Tuple(self, node: jinja2.nodes.Tuple, frame: jinja2.compiler.Frame) -> None
|
| visit_With(self, node: jinja2.nodes.With, frame: jinja2.compiler.Frame) -> None
|
| write(self, x: str) -> None
| Write a string into the output stream.
|
| write_commons(self) -> None
| Writes a common preamble that is used by root and block functions.
| Primarily this sets up common local helpers and enforces a generator
| through a dead branch.
|
| writeline(self, x: str, node: Optional[jinja2.nodes.Node] = None, extra: int = 0) -> None
| Combination of newline and write.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| optimized
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_finalize': typing.Optional[jinja2.compiler.CodeGe...
|
| ----------------------------------------------------------------------
| Methods inherited from jinja2.visitor.NodeVisitor:
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Called if no explicit visitor function exists for a node.
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from jinja2.visitor.NodeVisitor:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class CompilerExit(builtins.Exception)
| Raised if the compiler encountered a situation where it just
| doesn't make sense to further process the code. Any block that
| raises such an exception is not further processed.
|
| Method resolution order:
| CompilerExit
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class DependencyFinderVisitor(jinja2.visitor.NodeVisitor)
| DependencyFinderVisitor() -> None
|
| A visitor that collects filter and test calls.
|
| Method resolution order:
| DependencyFinderVisitor
| jinja2.visitor.NodeVisitor
| builtins.object
|
| Methods defined here:
|
| __init__(self) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| visit_Block(self, node: jinja2.nodes.Block) -> None
| Stop visiting at blocks.
|
| visit_Filter(self, node: jinja2.nodes.Filter) -> None
|
| visit_Test(self, node: jinja2.nodes.Test) -> None
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from jinja2.visitor.NodeVisitor:
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Called if no explicit visitor function exists for a node.
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from jinja2.visitor.NodeVisitor:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Frame(builtins.object)
| Frame(eval_ctx: jinja2.nodes.EvalContext, parent: Optional[ForwardRef('Frame')] = None, level: Optional[int] = None) -> None
|
| Holds compile time information for us.
|
| Methods defined here:
|
| __copy__ = copy(self) -> 'Frame'
|
| __init__(self, eval_ctx: jinja2.nodes.EvalContext, parent: Optional[ForwardRef('Frame')] = None, level: Optional[int] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| copy(self) -> 'Frame'
| Create a copy of the current one.
|
| inner(self, isolated: bool = False) -> 'Frame'
| Return an inner frame.
|
| soft(self) -> 'Frame'
| Return a soft frame. A soft frame may not be modified as
| standalone thing as it shares the resources with the frame it
| was created of, but it's not a rootlevel frame any longer.
|
| This is only used to implement if-statements and conditional
| expressions.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class MacroRef(builtins.object)
| MacroRef(node: Union[jinja2.nodes.Macro, jinja2.nodes.CallBlock]) -> None
|
| Methods defined here:
|
| __init__(self, node: Union[jinja2.nodes.Macro, jinja2.nodes.CallBlock]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class UndeclaredNameVisitor(jinja2.visitor.NodeVisitor)
| UndeclaredNameVisitor(names: Iterable[str]) -> None
|
| A visitor that checks if a name is accessed without being
| declared. This is different from the frame visitor as it will
| not stop at closure frames.
|
| Method resolution order:
| UndeclaredNameVisitor
| jinja2.visitor.NodeVisitor
| builtins.object
|
| Methods defined here:
|
| __init__(self, names: Iterable[str]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| visit_Block(self, node: jinja2.nodes.Block) -> None
| Stop visiting a blocks.
|
| visit_Name(self, node: jinja2.nodes.Name) -> None
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from jinja2.visitor.NodeVisitor:
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Called if no explicit visitor function exists for a node.
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from jinja2.visitor.NodeVisitor:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class VisitorExit(builtins.RuntimeError)
| Exception used by the `UndeclaredNameVisitor` to signal a stop.
|
| Method resolution order:
| VisitorExit
| builtins.RuntimeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.RuntimeError:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.RuntimeError:
|
| __new__(*args, **kwargs) class method of builtins.RuntimeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
FUNCTIONS
concat = join(iterable, /) method of builtins.str instance
Concatenate any number of strings.
The string whose method is called is inserted in between each given string.
The result is returned as a new string.
Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
escape(...)
Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in the string with HTML-safe sequences. Use this if you need to display text that might contain such characters in HTML.
If the object has an ``__html__`` method, it is called and the return value is assumed to already be safe for HTML.
:param s: An object to be converted to a string and escaped.
:return: A :class:`Markup` string with the escaped text.
find_undeclared(nodes: Iterable[jinja2.nodes.Node], names: Iterable[str]) -> Set[str]
Check if the names passed are accessed undeclared. The return value
is a set of all the undeclared names from the sequence of names found.
generate(node: jinja2.nodes.Template, environment: 'Environment', name: Optional[str], filename: Optional[str], stream: Optional[TextIO] = None, defer_init: bool = False, optimized: bool = True) -> Optional[str]
Generate the python source for a node tree.
has_safe_repr(value: Any) -> bool
Does the node have a safe representation?
is_python_keyword = __contains__(...) method of builtins.frozenset instance
x.__contains__(y) <==> y in x.
optimizeconst(f: ~F) -> ~F
DATA
F = ~F
VAR_LOAD_ALIAS = 'alias'
VAR_LOAD_PARAMETER = 'param'
VAR_LOAD_RESOLVE = 'resolve'
VAR_LOAD_UNDEFINED = 'undefined'
operators = {'eq': '==', 'gt': '>', 'gteq': '>=', 'in': 'in', 'lt': '<...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\compiler.py
jinja2.defaults
Python Library Documentation: module jinja2.defaults in jinja2
NAME
jinja2.defaults
DATA
BLOCK_END_STRING = '%}'
BLOCK_START_STRING = '{%'
COMMENT_END_STRING = '#}'
COMMENT_START_STRING = '{#'
DEFAULT_FILTERS = {'abs': <built-in function abs>, 'attr': <function d...
DEFAULT_NAMESPACE = {'cycler': <class 'jinja2.utils.Cycler'>, 'dict': ...
DEFAULT_POLICIES = {'compiler.ascii_str': True, 'ext.i18n.trimmed': Fa...
DEFAULT_TESTS = {'!=': <built-in function ne>, '<': <built-in function...
KEEP_TRAILING_NEWLINE = False
LINE_COMMENT_PREFIX = None
LINE_STATEMENT_PREFIX = None
LSTRIP_BLOCKS = False
NEWLINE_SEQUENCE = '\n'
TRIM_BLOCKS = False
VARIABLE_END_STRING = '}}'
VARIABLE_START_STRING = '{{'
__annotations__ = {'DEFAULT_POLICIES': typing.Dict[str, typing.Any], '...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\defaults.py
jinja2.environment
Python Library Documentation: module jinja2.environment in jinja2
NAME
jinja2.environment
DESCRIPTION
Classes for managing templates and their runtime and compile time
options.
CLASSES
builtins.object
Environment
Template
TemplateExpression
TemplateModule
TemplateStream
class Environment(builtins.object)
| Environment(block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, loader: Optional[ForwardRef('BaseLoader')] = None, cache_size: int = 400, auto_reload: bool = True, bytecode_cache: Optional[ForwardRef('BytecodeCache')] = None, enable_async: bool = False)
|
| The core component of Jinja is the `Environment`. It contains
| important shared variables like configuration, filters, tests,
| globals and others. Instances of this class may be modified if
| they are not shared and if no template was loaded so far.
| Modifications on environments after the first template was loaded
| will lead to surprising effects and undefined behavior.
|
| Here are the possible initialization parameters:
|
| `block_start_string`
| The string marking the beginning of a block. Defaults to ``'{%'``.
|
| `block_end_string`
| The string marking the end of a block. Defaults to ``'%}'``.
|
| `variable_start_string`
| The string marking the beginning of a print statement.
| Defaults to ``'{{'``.
|
| `variable_end_string`
| The string marking the end of a print statement. Defaults to
| ``'}}'``.
|
| `comment_start_string`
| The string marking the beginning of a comment. Defaults to ``'{#'``.
|
| `comment_end_string`
| The string marking the end of a comment. Defaults to ``'#}'``.
|
| `line_statement_prefix`
| If given and a string, this will be used as prefix for line based
| statements. See also :ref:`line-statements`.
|
| `line_comment_prefix`
| If given and a string, this will be used as prefix for line based
| comments. See also :ref:`line-statements`.
|
| .. versionadded:: 2.2
|
| `trim_blocks`
| If this is set to ``True`` the first newline after a block is
| removed (block, not variable tag!). Defaults to `False`.
|
| `lstrip_blocks`
| If this is set to ``True`` leading spaces and tabs are stripped
| from the start of a line to a block. Defaults to `False`.
|
| `newline_sequence`
| The sequence that starts a newline. Must be one of ``'\r'``,
| ``'\n'`` or ``'\r\n'``. The default is ``'\n'`` which is a
| useful default for Linux and OS X systems as well as web
| applications.
|
| `keep_trailing_newline`
| Preserve the trailing newline when rendering templates.
| The default is ``False``, which causes a single newline,
| if present, to be stripped from the end of the template.
|
| .. versionadded:: 2.7
|
| `extensions`
| List of Jinja extensions to use. This can either be import paths
| as strings or extension classes. For more information have a
| look at :ref:`the extensions documentation <jinja-extensions>`.
|
| `optimized`
| should the optimizer be enabled? Default is ``True``.
|
| `undefined`
| :class:`Undefined` or a subclass of it that is used to represent
| undefined values in the template.
|
| `finalize`
| A callable that can be used to process the result of a variable
| expression before it is output. For example one can convert
| ``None`` implicitly into an empty string here.
|
| `autoescape`
| If set to ``True`` the XML/HTML autoescaping feature is enabled by
| default. For more details about autoescaping see
| :class:`~markupsafe.Markup`. As of Jinja 2.4 this can also
| be a callable that is passed the template name and has to
| return ``True`` or ``False`` depending on autoescape should be
| enabled by default.
|
| .. versionchanged:: 2.4
| `autoescape` can now be a function
|
| `loader`
| The template loader for this environment.
|
| `cache_size`
| The size of the cache. Per default this is ``400`` which means
| that if more than 400 templates are loaded the loader will clean
| out the least recently used template. If the cache size is set to
| ``0`` templates are recompiled all the time, if the cache size is
| ``-1`` the cache will not be cleaned.
|
| .. versionchanged:: 2.8
| The cache size was increased to 400 from a low 50.
|
| `auto_reload`
| Some loaders load templates from locations where the template
| sources may change (ie: file system or database). If
| ``auto_reload`` is set to ``True`` (default) every time a template is
| requested the loader checks if the source changed and if yes, it
| will reload the template. For higher performance it's possible to
| disable that.
|
| `bytecode_cache`
| If set to a bytecode cache object, this object will provide a
| cache for the internal Jinja bytecode so that templates don't
| have to be parsed if they were not changed.
|
| See :ref:`bytecode-cache` for more information.
|
| `enable_async`
| If set to true this enables async template execution which
| allows using async functions and generators.
|
| Methods defined here:
|
| __init__(self, block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, loader: Optional[ForwardRef('BaseLoader')] = None, cache_size: int = 400, auto_reload: bool = True, bytecode_cache: Optional[ForwardRef('BytecodeCache')] = None, enable_async: bool = False)
| Initialize self. See help(type(self)) for accurate signature.
|
| add_extension(self, extension: Union[str, Type[ForwardRef('Extension')]]) -> None
| Adds an extension after the environment was created.
|
| .. versionadded:: 2.5
|
| call_filter(self, name: str, value: Any, args: Optional[Sequence[Any]] = None, kwargs: Optional[Mapping[str, Any]] = None, context: Optional[jinja2.runtime.Context] = None, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Invoke a filter on a value the same way the compiler does.
|
| This might return a coroutine if the filter is running from an
| environment in async mode and the filter supports async
| execution. It's your responsibility to await this if needed.
|
| .. versionadded:: 2.7
|
| call_test(self, name: str, value: Any, args: Optional[Sequence[Any]] = None, kwargs: Optional[Mapping[str, Any]] = None, context: Optional[jinja2.runtime.Context] = None, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Invoke a test on a value the same way the compiler does.
|
| This might return a coroutine if the test is running from an
| environment in async mode and the test supports async execution.
| It's your responsibility to await this if needed.
|
| .. versionchanged:: 3.0
| Tests support ``@pass_context``, etc. decorators. Added
| the ``context`` and ``eval_ctx`` parameters.
|
| .. versionadded:: 2.7
|
| compile(self, source: Union[str, jinja2.nodes.Template], name: Optional[str] = None, filename: Optional[str] = None, raw: bool = False, defer_init: bool = False) -> Union[str, code]
| Compile a node or template source code. The `name` parameter is
| the load name of the template after it was joined using
| :meth:`join_path` if necessary, not the filename on the file system.
| the `filename` parameter is the estimated filename of the template on
| the file system. If the template came from a database or memory this
| can be omitted.
|
| The return value of this method is a python code object. If the `raw`
| parameter is `True` the return value will be a string with python
| code equivalent to the bytecode returned otherwise. This method is
| mainly used internally.
|
| `defer_init` is use internally to aid the module code generator. This
| causes the generated code to be able to import without the global
| environment variable to be set.
|
| .. versionadded:: 2.4
| `defer_init` parameter added.
|
| compile_expression(self, source: str, undefined_to_none: bool = True) -> 'TemplateExpression'
| A handy helper method that returns a callable that accepts keyword
| arguments that appear as variables in the expression. If called it
| returns the result of the expression.
|
| This is useful if applications want to use the same rules as Jinja
| in template "configuration files" or similar situations.
|
| Example usage:
|
| >>> env = Environment()
| >>> expr = env.compile_expression('foo == 42')
| >>> expr(foo=23)
| False
| >>> expr(foo=42)
| True
|
| Per default the return value is converted to `None` if the
| expression returns an undefined value. This can be changed
| by setting `undefined_to_none` to `False`.
|
| >>> env.compile_expression('var')() is None
| True
| >>> env.compile_expression('var', undefined_to_none=False)()
| Undefined
|
| .. versionadded:: 2.1
|
| compile_templates(self, target: Union[str, ForwardRef('os.PathLike[str]')], extensions: Optional[Collection[str]] = None, filter_func: Optional[Callable[[str], bool]] = None, zip: Optional[str] = 'deflated', log_function: Optional[Callable[[str], NoneType]] = None, ignore_errors: bool = True) -> None
| Finds all the templates the loader can find, compiles them
| and stores them in `target`. If `zip` is `None`, instead of in a
| zipfile, the templates will be stored in a directory.
| By default a deflate zip algorithm is used. To switch to
| the stored algorithm, `zip` can be set to ``'stored'``.
|
| `extensions` and `filter_func` are passed to :meth:`list_templates`.
| Each template returned will be compiled to the target folder or
| zipfile.
|
| By default template compilation errors are ignored. In case a
| log function is provided, errors are logged. If you want template
| syntax errors to abort the compilation you can set `ignore_errors`
| to `False` and you will get an exception on syntax errors.
|
| .. versionadded:: 2.4
|
| extend(self, **attributes: Any) -> None
| Add the items to the instance of the environment if they do not exist
| yet. This is used by :ref:`extensions <writing-extensions>` to register
| callbacks and configuration values without breaking inheritance.
|
| from_string(self, source: Union[str, jinja2.nodes.Template], globals: Optional[MutableMapping[str, Any]] = None, template_class: Optional[Type[ForwardRef('Template')]] = None) -> 'Template'
| Load a template from a source string without using
| :attr:`loader`.
|
| :param source: Jinja source to compile into a template.
| :param globals: Extend the environment :attr:`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.
| :param template_class: Return an instance of this
| :class:`Template` class.
|
| get_or_select_template(self, template_name_or_list: Union[str, ForwardRef('Template'), List[Union[str, ForwardRef('Template')]]], parent: Optional[str] = None, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Use :meth:`select_template` if an iterable of template names
| is given, or :meth:`get_template` if one name is given.
|
| .. versionadded:: 2.3
|
| get_template(self, name: Union[str, ForwardRef('Template')], parent: Optional[str] = None, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Load a template by name with :attr:`loader` and return a
| :class:`Template`. If the template does not exist a
| :exc:`TemplateNotFound` exception is raised.
|
| :param name: Name of the template to load. When loading
| templates from the filesystem, "/" is used as the path
| separator, even on Windows.
| :param parent: The name of the parent template importing this
| template. :meth:`join_path` can be used to implement name
| transformations with this.
| :param globals: Extend the environment :attr:`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.
|
| .. versionchanged:: 3.0
| If a template is loaded from cache, ``globals`` will update
| the template's globals instead of ignoring the new values.
|
| .. versionchanged:: 2.4
| If ``name`` is a :class:`Template` object it is returned
| unchanged.
|
| getattr(self, obj: Any, attribute: str) -> Any
| Get an item or attribute of an object but prefer the attribute.
| Unlike :meth:`getitem` the attribute *must* be a string.
|
| getitem(self, obj: Any, argument: Union[str, Any]) -> Union[Any, jinja2.runtime.Undefined]
| Get an item or attribute of an object but prefer the item.
|
| handle_exception(self, source: Optional[str] = None) -> 'te.NoReturn'
| Exception handling helper. This is used internally to either raise
| rewritten exceptions or return a rendered traceback for the template.
|
| iter_extensions(self) -> Iterator[ForwardRef('Extension')]
| Iterates over the extensions by priority.
|
| join_path(self, template: str, parent: str) -> str
| Join a template with the parent. By default all the lookups are
| relative to the loader root so this method returns the `template`
| parameter unchanged, but if the paths should be relative to the
| parent template, this function can be used to calculate the real
| template name.
|
| Subclasses may override this method and implement template path
| joining here.
|
| lex(self, source: str, name: Optional[str] = None, filename: Optional[str] = None) -> Iterator[Tuple[int, str, str]]
| Lex the given sourcecode and return a generator that yields
| tokens as tuples in the form ``(lineno, token_type, value)``.
| This can be useful for :ref:`extension development <writing-extensions>`
| and debugging templates.
|
| This does not perform preprocessing. If you want the preprocessing
| of the extensions to be applied you have to filter source through
| the :meth:`preprocess` method.
|
| list_templates(self, extensions: Optional[Collection[str]] = None, filter_func: Optional[Callable[[str], bool]] = None) -> List[str]
| Returns a list of templates for this environment. This requires
| that the loader supports the loader's
| :meth:`~BaseLoader.list_templates` method.
|
| If there are other files in the template folder besides the
| actual templates, the returned list can be filtered. There are two
| ways: either `extensions` is set to a list of file extensions for
| templates, or a `filter_func` can be provided which is a callable that
| is passed a template name and should return `True` if it should end up
| in the result list.
|
| If the loader does not support that, a :exc:`TypeError` is raised.
|
| .. versionadded:: 2.4
|
| make_globals(self, d: Optional[MutableMapping[str, Any]]) -> MutableMapping[str, Any]
| Make the globals map for a template. Any given template
| globals overlay the environment :attr:`globals`.
|
| Returns a :class:`collections.ChainMap`. This allows any changes
| to a template's globals to only affect that template, while
| changes to the environment's globals are still reflected.
| However, avoid modifying any globals after a template is loaded.
|
| :param d: Dict of template-specific globals.
|
| .. versionchanged:: 3.0
| Use :class:`collections.ChainMap` to always prevent mutating
| environment globals.
|
| overlay(self, block_start_string: str = missing, block_end_string: str = missing, variable_start_string: str = missing, variable_end_string: str = missing, comment_start_string: str = missing, comment_end_string: str = missing, line_statement_prefix: Optional[str] = missing, line_comment_prefix: Optional[str] = missing, trim_blocks: bool = missing, lstrip_blocks: bool = missing, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = missing, keep_trailing_newline: bool = missing, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = missing, optimized: bool = missing, undefined: Type[jinja2.runtime.Undefined] = missing, finalize: Optional[Callable[..., Any]] = missing, autoescape: Union[bool, Callable[[Optional[str]], bool]] = missing, loader: Optional[ForwardRef('BaseLoader')] = missing, cache_size: int = missing, auto_reload: bool = missing, bytecode_cache: Optional[ForwardRef('BytecodeCache')] = missing, enable_async: bool = False) -> 'Environment'
| Create 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.
|
| 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.
|
| .. versionchanged:: 3.1.2
| Added the ``newline_sequence``,, ``keep_trailing_newline``,
| and ``enable_async`` parameters to match ``__init__``.
|
| parse(self, source: str, name: Optional[str] = None, filename: Optional[str] = None) -> jinja2.nodes.Template
| Parse the sourcecode and return the abstract syntax tree. This
| tree of nodes is used by the compiler to convert the template into
| executable source- or bytecode. This is useful for debugging or to
| extract information from templates.
|
| If you are :ref:`developing Jinja extensions <writing-extensions>`
| this gives you a good overview of the node tree generated.
|
| preprocess(self, source: str, name: Optional[str] = None, filename: Optional[str] = None) -> str
| Preprocesses the source with all extensions. This is automatically
| called for all parsing and compiling methods but *not* for :meth:`lex`
| because there you usually only want the actual source tokenized.
|
| select_template(self, names: Iterable[Union[str, ForwardRef('Template')]], parent: Optional[str] = None, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Like :meth:`get_template`, but tries loading multiple names.
| If none of the names can be loaded a :exc:`TemplatesNotFound`
| exception is raised.
|
| :param names: List of template names to try loading in order.
| :param parent: The name of the parent template importing this
| template. :meth:`join_path` can be used to implement name
| transformations with this.
| :param globals: Extend the environment :attr:`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.
|
| .. versionchanged:: 3.0
| If a template is loaded from cache, ``globals`` will update
| the template's globals instead of ignoring the new values.
|
| .. versionchanged:: 2.11
| If ``names`` is :class:`Undefined`, an :exc:`UndefinedError`
| is raised instead. If no templates were found and ``names``
| contains :class:`Undefined`, the message is more helpful.
|
| .. versionchanged:: 2.4
| If ``names`` contains a :class:`Template` object it is
| returned unchanged.
|
| .. versionadded:: 2.3
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| concat = join(iterable, /) method of builtins.str instance
| Concatenate any number of strings.
|
| The string whose method is called is inserted in between each given string.
| The result is returned as a new string.
|
| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| lexer
| The lexer for this environment.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'code_generator_class': typing.Type[ForwardRef('Cod...
|
| code_generator_class = <class 'jinja2.compiler.CodeGenerator'>
|
| context_class = <class 'jinja2.runtime.Context'>
| The template context holds the variables of a template. It stores the
| values passed to the template and also the names the template exports.
| Creating instances is neither supported nor useful as it's created
| automatically at various stages of the template evaluation and should not
| be created by hand.
|
| The context is immutable. Modifications on :attr:`parent` **must not**
| happen and modifications on :attr:`vars` are allowed from generated
| template code only. Template filters and global functions marked as
| :func:`pass_context` get the active context passed as first argument
| and are allowed to access the context read-only.
|
| The template context supports read only dict operations (`get`,
| `keys`, `values`, `items`, `iterkeys`, `itervalues`, `iteritems`,
| `__getitem__`, `__contains__`). Additionally there is a :meth:`resolve`
| method that doesn't fail with a `KeyError` but returns an
| :class:`Undefined` object for missing variables.
|
|
| linked_to = None
|
| overlayed = False
|
| sandboxed = False
|
| shared = False
|
| template_class = <class 'jinja2.environment.Template'>
| A compiled template that can be rendered.
|
| Use the methods on :class:`Environment` to create or load templates.
| The environment is used to configure how templates are compiled and
| behave.
|
| It is also possible to create a template object directly. This is
| not usually recommended. The constructor takes most of the same
| arguments as :class:`Environment`. All templates created with the
| same environment arguments share the same ephemeral ``Environment``
| instance behind the scenes.
|
| A template object should be considered immutable. Modifications on
| the object are not supported.
class Template(builtins.object)
| Template(source: Union[str, jinja2.nodes.Template], block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, enable_async: bool = False) -> Any
|
| A compiled template that can be rendered.
|
| Use the methods on :class:`Environment` to create or load templates.
| The environment is used to configure how templates are compiled and
| behave.
|
| It is also possible to create a template object directly. This is
| not usually recommended. The constructor takes most of the same
| arguments as :class:`Environment`. All templates created with the
| same environment arguments share the same ephemeral ``Environment``
| instance behind the scenes.
|
| A template object should be considered immutable. Modifications on
| the object are not supported.
|
| Methods defined here:
|
| __repr__(self) -> str
| Return repr(self).
|
| generate(self, *args: Any, **kwargs: Any) -> Iterator[str]
| For very large templates it can be useful to not render the whole
| template at once but evaluate each statement after another and yield
| piece for piece. This method basically does exactly that and returns
| a generator that yields one item after another as strings.
|
| It accepts the same arguments as :meth:`render`.
|
| async generate_async(self, *args: Any, **kwargs: Any) -> AsyncIterator[str]
| An async version of :meth:`generate`. Works very similarly but
| returns an async iterator instead.
|
| get_corresponding_lineno(self, lineno: int) -> int
| Return the source line number of a line number in the
| generated bytecode as they are not in sync.
|
| make_module(self, vars: Optional[Dict[str, Any]] = None, shared: bool = False, locals: Optional[Mapping[str, Any]] = None) -> 'TemplateModule'
| This method works like the :attr:`module` attribute when called
| without arguments but it will evaluate the template on every call
| rather than caching it. It's also possible to provide
| a dict which is then used as context. The arguments are the same
| as for the :meth:`new_context` method.
|
| async make_module_async(self, vars: Optional[Dict[str, Any]] = None, shared: bool = False, locals: Optional[Mapping[str, Any]] = None) -> 'TemplateModule'
| As template module creation can invoke template code for
| asynchronous executions this method must be used instead of the
| normal :meth:`make_module` one. Likewise the module attribute
| becomes unavailable in async mode.
|
| new_context(self, vars: Optional[Dict[str, Any]] = None, shared: bool = False, locals: Optional[Mapping[str, Any]] = None) -> jinja2.runtime.Context
| Create a new :class:`Context` for this template. The vars
| provided will be passed to the template. Per default the globals
| are added to the context. If shared is set to `True` the data
| is passed as is to the context without adding the globals.
|
| `locals` can be a dict of local variables for internal usage.
|
| render(self, *args: Any, **kwargs: Any) -> str
| This method accepts the same arguments as the `dict` constructor:
| A dict, a dict subclass or some keyword arguments. If no arguments
| are given the context will be empty. These two calls do the same::
|
| template.render(knights='that say nih')
| template.render({'knights': 'that say nih'})
|
| This will return the rendered template as a string.
|
| async render_async(self, *args: Any, **kwargs: Any) -> str
| This works similar to :meth:`render` but returns a coroutine
| that when awaited returns the entire rendered template string. This
| requires the async feature to be enabled.
|
| Example usage::
|
| await template.render_async(knights='that say nih; asynchronously')
|
| stream(self, *args: Any, **kwargs: Any) -> 'TemplateStream'
| Works exactly like :meth:`generate` but returns a
| :class:`TemplateStream`.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_code(environment: jinja2.environment.Environment, code: code, globals: MutableMapping[str, Any], uptodate: Optional[Callable[[], bool]] = None) -> 'Template'
| Creates a template object from compiled code and the globals. This
| is used by the loaders and environment to create a template object.
|
| from_module_dict(environment: jinja2.environment.Environment, module_dict: MutableMapping[str, Any], globals: MutableMapping[str, Any]) -> 'Template'
| Creates a template object from a module. This is used by the
| module loader to create a template object.
|
| .. versionadded:: 2.4
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, source: Union[str, jinja2.nodes.Template], block_start_string: str = '{%', block_end_string: str = '%}', variable_start_string: str = '{{', variable_end_string: str = '}}', comment_start_string: str = '{#', comment_end_string: str = '#}', line_statement_prefix: Optional[str] = None, line_comment_prefix: Optional[str] = None, trim_blocks: bool = False, lstrip_blocks: bool = False, newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = '\n', keep_trailing_newline: bool = False, extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]] = (), optimized: bool = True, undefined: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>, finalize: Optional[Callable[..., Any]] = None, autoescape: Union[bool, Callable[[Optional[str]], bool]] = False, enable_async: bool = False) -> Any
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| debug_info
| The debug info mapping.
|
| is_up_to_date
| If this variable is `False` there is a newer version available.
|
| module
| The template as module. This is used for imports in the
| template runtime but is also useful if one wants to access
| exported template variables from the Python layer:
|
| >>> t = Template('{% macro foo() %}42{% endmacro %}23')
| >>> str(t.module)
| '23'
| >>> t.module.foo() == u'42'
| True
|
| This attribute is not available if async mode is enabled.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_debug_info': <class 'str'>, '_module': typing.Opt...
|
| environment_class = <class 'jinja2.environment.Environment'>
| The core component of Jinja is the `Environment`. It contains
| important shared variables like configuration, filters, tests,
| globals and others. Instances of this class may be modified if
| they are not shared and if no template was loaded so far.
| Modifications on environments after the first template was loaded
| will lead to surprising effects and undefined behavior.
|
| Here are the possible initialization parameters:
|
| `block_start_string`
| The string marking the beginning of a block. Defaults to ``'{%'``.
|
| `block_end_string`
| The string marking the end of a block. Defaults to ``'%}'``.
|
| `variable_start_string`
| The string marking the beginning of a print statement.
| Defaults to ``'{{'``.
|
| `variable_end_string`
| The string marking the end of a print statement. Defaults to
| ``'}}'``.
|
| `comment_start_string`
| The string marking the beginning of a comment. Defaults to ``'{#'``.
|
| `comment_end_string`
| The string marking the end of a comment. Defaults to ``'#}'``.
|
| `line_statement_prefix`
| If given and a string, this will be used as prefix for line based
| statements. See also :ref:`line-statements`.
|
| `line_comment_prefix`
| If given and a string, this will be used as prefix for line based
| comments. See also :ref:`line-statements`.
|
| .. versionadded:: 2.2
|
| `trim_blocks`
| If this is set to ``True`` the first newline after a block is
| removed (block, not variable tag!). Defaults to `False`.
|
| `lstrip_blocks`
| If this is set to ``True`` leading spaces and tabs are stripped
| from the start of a line to a block. Defaults to `False`.
|
| `newline_sequence`
| The sequence that starts a newline. Must be one of ``'\r'``,
| ``'\n'`` or ``'\r\n'``. The default is ``'\n'`` which is a
| useful default for Linux and OS X systems as well as web
| applications.
|
| `keep_trailing_newline`
| Preserve the trailing newline when rendering templates.
| The default is ``False``, which causes a single newline,
| if present, to be stripped from the end of the template.
|
| .. versionadded:: 2.7
|
| `extensions`
| List of Jinja extensions to use. This can either be import paths
| as strings or extension classes. For more information have a
| look at :ref:`the extensions documentation <jinja-extensions>`.
|
| `optimized`
| should the optimizer be enabled? Default is ``True``.
|
| `undefined`
| :class:`Undefined` or a subclass of it that is used to represent
| undefined values in the template.
|
| `finalize`
| A callable that can be used to process the result of a variable
| expression before it is output. For example one can convert
| ``None`` implicitly into an empty string here.
|
| `autoescape`
| If set to ``True`` the XML/HTML autoescaping feature is enabled by
| default. For more details about autoescaping see
| :class:`~markupsafe.Markup`. As of Jinja 2.4 this can also
| be a callable that is passed the template name and has to
| return ``True`` or ``False`` depending on autoescape should be
| enabled by default.
|
| .. versionchanged:: 2.4
| `autoescape` can now be a function
|
| `loader`
| The template loader for this environment.
|
| `cache_size`
| The size of the cache. Per default this is ``400`` which means
| that if more than 400 templates are loaded the loader will clean
| out the least recently used template. If the cache size is set to
| ``0`` templates are recompiled all the time, if the cache size is
| ``-1`` the cache will not be cleaned.
|
| .. versionchanged:: 2.8
| The cache size was increased to 400 from a low 50.
|
| `auto_reload`
| Some loaders load templates from locations where the template
| sources may change (ie: file system or database). If
| ``auto_reload`` is set to ``True`` (default) every time a template is
| requested the loader checks if the source changed and if yes, it
| will reload the template. For higher performance it's possible to
| disable that.
|
| `bytecode_cache`
| If set to a bytecode cache object, this object will provide a
| cache for the internal Jinja bytecode so that templates don't
| have to be parsed if they were not changed.
|
| See :ref:`bytecode-cache` for more information.
|
| `enable_async`
| If set to true this enables async template execution which
| allows using async functions and generators.
class TemplateExpression(builtins.object)
| TemplateExpression(template: jinja2.environment.Template, undefined_to_none: bool) -> None
|
| The :meth:`jinja2.Environment.compile_expression` method returns an
| instance of this object. It encapsulates the expression-like access
| to the template with an expression it wraps.
|
| Methods defined here:
|
| __call__(self, *args: Any, **kwargs: Any) -> Optional[Any]
| Call self as a function.
|
| __init__(self, template: jinja2.environment.Template, undefined_to_none: bool) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class TemplateModule(builtins.object)
| TemplateModule(template: jinja2.environment.Template, context: jinja2.runtime.Context, body_stream: Optional[Iterable[str]] = None) -> None
|
| Represents an imported template. All the exported names of the
| template are available as attributes on this object. Additionally
| converting it into a string renders the contents.
|
| Methods defined here:
|
| __html__(self) -> markupsafe.Markup
|
| __init__(self, template: jinja2.environment.Template, context: jinja2.runtime.Context, body_stream: Optional[Iterable[str]] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class TemplateStream(builtins.object)
| TemplateStream(gen: Iterator[str]) -> None
|
| A template stream works pretty much like an ordinary python generator
| but it can buffer multiple items to reduce the number of total iterations.
| Per default the output is unbuffered which means that for every unbuffered
| instruction in the template one string is yielded.
|
| If buffering is enabled with a buffer size of 5, five items are combined
| into a new string. This is mainly useful if you are streaming
| big templates to a client via WSGI which flushes after each iteration.
|
| Methods defined here:
|
| __init__(self, gen: Iterator[str]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self) -> 'TemplateStream'
|
| __next__(self) -> str
|
| disable_buffering(self) -> None
| Disable the output buffering.
|
| dump(self, fp: Union[str, IO[bytes]], encoding: Optional[str] = None, errors: Optional[str] = 'strict') -> None
| Dump the complete stream into a file or file-like object.
| Per default strings are written, if you want to encode
| before writing specify an `encoding`.
|
| Example usage::
|
| Template('Hello {{ name }}!').stream(name='foo').dump('hello.html')
|
| enable_buffering(self, size: int = 5) -> None
| Enable buffering. Buffer `size` items before yielding them.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
concat = join(iterable, /) method of builtins.str instance
Concatenate any number of strings.
The string whose method is called is inserted in between each given string.
The result is returned as a new string.
Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
copy_cache(cache: Optional[MutableMapping[Any, Any]]) -> Optional[MutableMapping[Tuple[ForwardRef('weakref.ref[t.Any]'), str], ForwardRef('Template')]]
Create an empty copy of the given cache.
create_cache(size: int) -> Optional[MutableMapping[Tuple[ForwardRef('weakref.ref[t.Any]'), str], ForwardRef('Template')]]
Return the cache class for the given size.
get_spontaneous_environment(cls: Type[~_env_bound], *args: Any) -> ~_env_bound
Return a new spontaneous environment. A spontaneous environment
is used for templates created directly rather than through an
existing environment.
:param cls: Environment class to create.
:param args: Positional arguments passed to environment.
load_extensions(environment: 'Environment', extensions: Sequence[Union[str, Type[ForwardRef('Extension')]]]) -> Dict[str, ForwardRef('Extension')]
Load the extensions from the list and bind it to the environment.
Returns a dict of instantiated extensions.
reduce(...)
reduce(function, iterable[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence
or iterable, from left to right, so as to reduce the iterable to a single
value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the iterable in the calculation, and serves as a default when the
iterable is empty.
DATA
BLOCK_END_STRING = '%}'
BLOCK_START_STRING = '{%'
COMMENT_END_STRING = '#}'
COMMENT_START_STRING = '{#'
DEFAULT_FILTERS = {'abs': <built-in function abs>, 'attr': <function d...
DEFAULT_NAMESPACE = {'cycler': <class 'jinja2.utils.Cycler'>, 'dict': ...
DEFAULT_POLICIES = {'compiler.ascii_str': True, 'ext.i18n.trimmed': Fa...
DEFAULT_TESTS = {'!=': <built-in function ne>, '<': <built-in function...
KEEP_TRAILING_NEWLINE = False
LINE_COMMENT_PREFIX = None
LINE_STATEMENT_PREFIX = None
LSTRIP_BLOCKS = False
NEWLINE_SEQUENCE = '\n'
TRIM_BLOCKS = False
VARIABLE_END_STRING = '}}'
VARIABLE_START_STRING = '{{'
missing = missing
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\environment.py
jinja2.exceptions
Python Library Documentation: module jinja2.exceptions in jinja2
NAME
jinja2.exceptions
CLASSES
builtins.Exception(builtins.BaseException)
TemplateError
TemplateNotFound(builtins.OSError, builtins.LookupError, TemplateError)
TemplatesNotFound
TemplateRuntimeError
FilterArgumentError
SecurityError
UndefinedError
TemplateSyntaxError
TemplateAssertionError
builtins.LookupError(builtins.Exception)
TemplateNotFound(builtins.OSError, builtins.LookupError, TemplateError)
TemplatesNotFound
builtins.OSError(builtins.Exception)
TemplateNotFound(builtins.OSError, builtins.LookupError, TemplateError)
TemplatesNotFound
class FilterArgumentError(TemplateRuntimeError)
| FilterArgumentError(message: Optional[str] = None) -> None
|
| This error is raised if a filter was called with inappropriate
| arguments
|
| Method resolution order:
| FilterArgumentError
| TemplateRuntimeError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateError:
|
| __init__(self, message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class SecurityError(TemplateRuntimeError)
| SecurityError(message: Optional[str] = None) -> None
|
| Raised if a template tries to do something insecure if the
| sandbox is enabled.
|
| Method resolution order:
| SecurityError
| TemplateRuntimeError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateError:
|
| __init__(self, message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class TemplateAssertionError(TemplateSyntaxError)
| TemplateAssertionError(message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None
|
| Like a template syntax error, but covers cases where something in the
| template caused an error at compile time that wasn't necessarily caused
| by a syntax error. However it's a direct subclass of
| :exc:`TemplateSyntaxError` and has the same attributes.
|
| Method resolution order:
| TemplateAssertionError
| TemplateSyntaxError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateSyntaxError:
|
| __init__(self, message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(self)
| Helper for pickle.
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class TemplateError(builtins.Exception)
| TemplateError(message: Optional[str] = None) -> None
|
| Baseclass for all template errors.
|
| Method resolution order:
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class TemplateNotFound(builtins.OSError, builtins.LookupError, TemplateError)
| TemplateNotFound(name: Union[str, ForwardRef('Undefined'), NoneType], message: Optional[str] = None) -> None
|
| Raised if a template does not exist.
|
| .. versionchanged:: 2.11
| If the given name is :class:`Undefined` and no message was
| provided, an :exc:`UndefinedError` is raised.
|
| Method resolution order:
| TemplateNotFound
| builtins.OSError
| builtins.LookupError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, name: Union[str, ForwardRef('Undefined'), NoneType], message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'message': typing.Optional[str]}
|
| message = None
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __reduce__(...)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.OSError:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class TemplateRuntimeError(TemplateError)
| TemplateRuntimeError(message: Optional[str] = None) -> None
|
| A generic runtime error in the template engine. Under some situations
| Jinja may raise this exception.
|
| Method resolution order:
| TemplateRuntimeError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateError:
|
| __init__(self, message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class TemplateSyntaxError(TemplateError)
| TemplateSyntaxError(message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None
|
| Raised to tell the user that there is a problem with the template.
|
| Method resolution order:
| TemplateSyntaxError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message: str, lineno: int, name: Optional[str] = None, filename: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(self)
| Helper for pickle.
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class TemplatesNotFound(TemplateNotFound)
| TemplatesNotFound(names: Sequence[Union[str, ForwardRef('Undefined')]] = (), message: Optional[str] = None) -> None
|
| Like :class:`TemplateNotFound` but raised if multiple templates
| are selected. This is a subclass of :class:`TemplateNotFound`
| exception, so just catching the base exception will catch both.
|
| .. versionchanged:: 2.11
| If a name in the list of names is :class:`Undefined`, a message
| about it being undefined is shown rather than the empty string.
|
| .. versionadded:: 2.2
|
| Method resolution order:
| TemplatesNotFound
| TemplateNotFound
| builtins.OSError
| builtins.LookupError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, names: Sequence[Union[str, ForwardRef('Undefined')]] = (), message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateNotFound:
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateNotFound:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TemplateNotFound:
|
| message = None
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __reduce__(...)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.OSError:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class UndefinedError(TemplateRuntimeError)
| UndefinedError(message: Optional[str] = None) -> None
|
| Raised if a template tries to operate on :class:`Undefined`.
|
| Method resolution order:
| UndefinedError
| TemplateRuntimeError
| TemplateError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from TemplateError:
|
| __init__(self, message: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from TemplateError:
|
| message
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TemplateError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\exceptions.py
jinja2.filters
Python Library Documentation: module jinja2.filters in jinja2
NAME
jinja2.filters - Built-in template filters used with the ``|`` operator.
FUNCTIONS
async async_select_or_reject(context: 'Context', value: 't.Union[t.AsyncIterable[V], t.Iterable[V]]', args: Tuple[Any, ...], kwargs: Dict[str, Any], modfunc: Callable[[Any], Any], lookup_attr: bool) -> 't.AsyncIterator[V]'
do_attr(environment: 'Environment', obj: Any, name: str) -> Union[jinja2.runtime.Undefined, Any]
Get an attribute of an object. ``foo|attr("bar")`` works like
``foo.bar`` just that always an attribute is returned and items are not
looked up.
See :ref:`Notes on subscriptions <notes-on-subscriptions>` for more details.
do_batch(value: 't.Iterable[V]', linecount: int, fill_with: 't.Optional[V]' = None) -> 't.Iterator[t.List[V]]'
A filter that batches items. It works pretty much like `slice`
just the other way round. It returns a list of lists with the
given number of items. If you provide a second parameter this
is used to fill up missing items. See this example:
.. sourcecode:: html+jinja
<table>
{%- for row in items|batch(3, ' ') %}
<tr>
{%- for column in row %}
<td>{{ column }}</td>
{%- endfor %}
</tr>
{%- endfor %}
</table>
do_capitalize(s: str) -> str
Capitalize a value. The first character will be uppercase, all others
lowercase.
do_center(value: str, width: int = 80) -> str
Centers the value in a field of a given width.
do_default(value: ~V, default_value: ~V = '', boolean: bool = False) -> ~V
If the value is undefined it will return the passed default value,
otherwise the value of the variable:
.. sourcecode:: jinja
{{ my_variable|default('my_variable is not defined') }}
This will output the value of ``my_variable`` if the variable was
defined, otherwise ``'my_variable is not defined'``. If you want
to use default with variables that evaluate to false you have to
set the second parameter to `true`:
.. sourcecode:: jinja
{{ ''|default('the string was empty', true) }}
.. versionchanged:: 2.11
It's now possible to configure the :class:`~jinja2.Environment` with
:class:`~jinja2.ChainableUndefined` to make the `default` filter work
on nested elements and attributes that may contain undefined values
in the chain without getting an :exc:`~jinja2.UndefinedError`.
do_dictsort(value: Mapping[~K, ~V], case_sensitive: bool = False, by: 'te.Literal["key", "value"]' = 'key', reverse: bool = False) -> List[Tuple[~K, ~V]]
Sort a dict and yield (key, value) pairs. Python dicts may not
be in the order you want to display them in, so sort them first.
.. sourcecode:: jinja
{% for key, value in mydict|dictsort %}
sort the dict by key, case insensitive
{% for key, value in mydict|dictsort(reverse=true) %}
sort the dict by key, case insensitive, reverse order
{% for key, value in mydict|dictsort(true) %}
sort the dict by key, case sensitive
{% for key, value in mydict|dictsort(false, 'value') %}
sort the dict by value, case insensitive
do_filesizeformat(value: Union[str, float, int], binary: bool = False) -> str
Format the value like a 'human-readable' file size (i.e. 13 kB,
4.1 MB, 102 Bytes, etc). Per default decimal prefixes are used (Mega,
Giga, etc.), if the second parameter is set to `True` the binary
prefixes are used (Mebi, Gibi).
do_first(environment: 'Environment', seq: 't.Iterable[V]') -> 't.Union[V, Undefined]'
Return the first item of a sequence.
do_float(value: Any, default: float = 0.0) -> float
Convert the value into a floating point number. If the
conversion doesn't work it will return ``0.0``. You can
override this default using the first parameter.
do_forceescape(value: 't.Union[str, HasHTML]') -> markupsafe.Markup
Enforce HTML escaping. This will probably double escape variables.
do_format(value: str, *args: Any, **kwargs: Any) -> str
Apply the given values to a `printf-style`_ format string, like
``string % values``.
.. sourcecode:: jinja
{{ "%s, %s!"|format(greeting, name) }}
Hello, World!
In most cases it should be more convenient and efficient to use the
``%`` operator or :meth:`str.format`.
.. code-block:: text
{{ "%s, %s!" % (greeting, name) }}
{{ "{}, {}!".format(greeting, name) }}
.. _printf-style: https://docs.python.org/library/stdtypes.html
#printf-style-string-formatting
do_groupby(environment: 'Environment', value: 't.Iterable[V]', attribute: Union[str, int], default: Optional[Any] = None, case_sensitive: bool = False) -> 't.List[_GroupTuple]'
Group a sequence of objects by an attribute using Python's
:func:`itertools.groupby`. The attribute can use dot notation for
nested access, like ``"address.city"``. Unlike Python's ``groupby``,
the values are sorted first so only one group is returned for each
unique value.
For example, a list of ``User`` objects with a ``city`` attribute
can be rendered in groups. In this example, ``grouper`` refers to
the ``city`` value of the group.
.. sourcecode:: html+jinja
<ul>{% for city, items in users|groupby("city") %}
<li>{{ city }}
<ul>{% for user in items %}
<li>{{ user.name }}
{% endfor %}</ul>
</li>
{% endfor %}</ul>
``groupby`` yields namedtuples of ``(grouper, list)``, which
can be used instead of the tuple unpacking above. ``grouper`` is the
value of the attribute, and ``list`` is the items with that value.
.. sourcecode:: html+jinja
<ul>{% for group in users|groupby("city") %}
<li>{{ group.grouper }}: {{ group.list|join(", ") }}
{% endfor %}</ul>
You can specify a ``default`` value to use if an object in the list
does not have the given attribute.
.. sourcecode:: jinja
<ul>{% for city, items in users|groupby("city", default="NY") %}
<li>{{ city }}: {{ items|map(attribute="name")|join(", ") }}</li>
{% endfor %}</ul>
Like the :func:`~jinja-filters.sort` filter, sorting and grouping is
case-insensitive by default. The ``key`` for each group will have
the case of the first item in that group of values. For example, if
a list of users has cities ``["CA", "NY", "ca"]``, the "CA" group
will have two values. This can be disabled by passing
``case_sensitive=True``.
.. versionchanged:: 3.1
Added the ``case_sensitive`` parameter. Sorting and grouping is
case-insensitive by default, matching other filters that do
comparisons.
.. versionchanged:: 3.0
Added the ``default`` parameter.
.. versionchanged:: 2.6
The attribute supports dot notation for nested access.
do_indent(s: str, width: Union[int, str] = 4, first: bool = False, blank: bool = False) -> str
Return a copy of the string with each line indented by 4 spaces. The
first line and blank lines are not indented by default.
:param width: Number of spaces, or a string, to indent by.
:param first: Don't skip indenting the first line.
:param blank: Don't skip indenting empty lines.
.. versionchanged:: 3.0
``width`` can be a string.
.. versionchanged:: 2.10
Blank lines are not indented by default.
Rename the ``indentfirst`` argument to ``first``.
do_int(value: Any, default: int = 0, base: int = 10) -> int
Convert the value into an integer. If the
conversion doesn't work it will return ``0``. You can
override this default using the first parameter. You
can also override the default base (10) in the second
parameter, which handles input with prefixes such as
0b, 0o and 0x for bases 2, 8 and 16 respectively.
The base is ignored for decimal numbers and non-string values.
do_items(value: Union[Mapping[~K, ~V], jinja2.runtime.Undefined]) -> Iterator[Tuple[~K, ~V]]
Return an iterator over the ``(key, value)`` items of a mapping.
``x|items`` is the same as ``x.items()``, except if ``x`` is
undefined an empty iterator is returned.
This filter is useful if you expect the template to be rendered with
an implementation of Jinja in another programming language that does
not have a ``.items()`` method on its mapping type.
.. code-block:: html+jinja
<dl>
{% for key, value in my_dict|items %}
<dt>{{ key }}
<dd>{{ value }}
{% endfor %}
</dl>
.. versionadded:: 3.1
do_join(eval_ctx: 'EvalContext', value: Iterable[Any], d: str = '', attribute: Union[str, int, NoneType] = None) -> str
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is an empty string per
default, you can define it with the optional parameter:
.. sourcecode:: jinja
{{ [1, 2, 3]|join('|') }}
-> 1|2|3
{{ [1, 2, 3]|join }}
-> 123
It is also possible to join certain attributes of an object:
.. sourcecode:: jinja
{{ users|join(', ', attribute='username') }}
.. versionadded:: 2.6
The `attribute` parameter was added.
do_last(environment: 'Environment', seq: 't.Reversible[V]') -> 't.Union[V, Undefined]'
Return the last item of a sequence.
Note: Does not work with generators. You may want to explicitly
convert it to a list:
.. sourcecode:: jinja
{{ data | selectattr('name', '==', 'Jinja') | list | last }}
do_list(value: 't.Iterable[V]') -> 't.List[V]'
Convert the value into a list. If it was a string the returned list
will be a list of characters.
do_lower(s: str) -> str
Convert a value to lowercase.
do_map(context: 'Context', value: Iterable[Any], *args: Any, **kwargs: Any) -> Iterable[Any]
Applies a filter on a sequence of objects or looks up an attribute.
This is useful when dealing with lists of objects but you are really
only interested in a certain value of it.
The basic usage is mapping on an attribute. Imagine you have a list
of users but you are only interested in a list of usernames:
.. sourcecode:: jinja
Users on this page: {{ users|map(attribute='username')|join(', ') }}
You can specify a ``default`` value to use if an object in the list
does not have the given attribute.
.. sourcecode:: jinja
{{ users|map(attribute="username", default="Anonymous")|join(", ") }}
Alternatively you can let it invoke a filter by passing the name of the
filter and the arguments afterwards. A good example would be applying a
text conversion filter on a sequence:
.. sourcecode:: jinja
Users on this page: {{ titles|map('lower')|join(', ') }}
Similar to a generator comprehension such as:
.. code-block:: python
(u.username for u in users)
(getattr(u, "username", "Anonymous") for u in users)
(do_lower(x) for x in titles)
.. versionchanged:: 2.11.0
Added the ``default`` parameter.
.. versionadded:: 2.7
do_mark_safe(value: str) -> markupsafe.Markup
Mark the value as safe which means that in an environment with automatic
escaping enabled this variable will not be escaped.
do_mark_unsafe(value: str) -> str
Mark a value as unsafe. This is the reverse operation for :func:`safe`.
do_max(environment: 'Environment', value: 't.Iterable[V]', case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None) -> 't.Union[V, Undefined]'
Return the largest item from the sequence.
.. sourcecode:: jinja
{{ [1, 2, 3]|max }}
-> 3
:param case_sensitive: Treat upper and lower case strings as distinct.
:param attribute: Get the object with the max value of this attribute.
do_min(environment: 'Environment', value: 't.Iterable[V]', case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None) -> 't.Union[V, Undefined]'
Return the smallest item from the sequence.
.. sourcecode:: jinja
{{ [1, 2, 3]|min }}
-> 1
:param case_sensitive: Treat upper and lower case strings as distinct.
:param attribute: Get the object with the min value of this attribute.
do_pprint(value: Any) -> str
Pretty print a variable. Useful for debugging.
do_random(context: 'Context', seq: 't.Sequence[V]') -> 't.Union[V, Undefined]'
Return a random item from the sequence.
do_reject(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to each object,
and rejecting the objects with the test succeeding.
If no test is specified, each object will be evaluated as a boolean.
Example usage:
.. sourcecode:: jinja
{{ numbers|reject("odd") }}
Similar to a generator comprehension such as:
.. code-block:: python
(n for n in numbers if not test_odd(n))
.. versionadded:: 2.7
do_rejectattr(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to the specified
attribute of each object, and rejecting the objects with the test
succeeding.
If no test is specified, the attribute's value will be evaluated as
a boolean.
.. sourcecode:: jinja
{{ users|rejectattr("is_active") }}
{{ users|rejectattr("email", "none") }}
Similar to a generator comprehension such as:
.. code-block:: python
(u for user in users if not user.is_active)
(u for user in users if not test_none(user.email))
.. versionadded:: 2.7
do_replace(eval_ctx: 'EvalContext', s: str, old: str, new: str, count: Optional[int] = None) -> str
Return a copy of the value with all occurrences of a substring
replaced with a new one. The first argument is the substring
that should be replaced, the second is the replacement string.
If the optional third argument ``count`` is given, only the first
``count`` occurrences are replaced:
.. sourcecode:: jinja
{{ "Hello World"|replace("Hello", "Goodbye") }}
-> Goodbye World
{{ "aaaaargh"|replace("a", "d'oh, ", 2) }}
-> d'oh, d'oh, aaargh
do_reverse(value: Union[str, Iterable[~V]]) -> Union[str, Iterable[~V]]
Reverse the object or return an iterator that iterates over it the other
way round.
do_round(value: float, precision: int = 0, method: 'te.Literal["common", "ceil", "floor"]' = 'common') -> float
Round the number to a given precision. The first
parameter specifies the precision (default is ``0``), the
second the rounding method:
- ``'common'`` rounds either up or down
- ``'ceil'`` always rounds up
- ``'floor'`` always rounds down
If you don't specify a method ``'common'`` is used.
.. sourcecode:: jinja
{{ 42.55|round }}
-> 43.0
{{ 42.55|round(1, 'floor') }}
-> 42.5
Note that even if rounded to 0 precision, a float is returned. If
you need a real integer, pipe it through `int`:
.. sourcecode:: jinja
{{ 42.55|round|int }}
-> 43
do_select(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to each object,
and only selecting the objects with the test succeeding.
If no test is specified, each object will be evaluated as a boolean.
Example usage:
.. sourcecode:: jinja
{{ numbers|select("odd") }}
{{ numbers|select("odd") }}
{{ numbers|select("divisibleby", 3) }}
{{ numbers|select("lessthan", 42) }}
{{ strings|select("equalto", "mystring") }}
Similar to a generator comprehension such as:
.. code-block:: python
(n for n in numbers if test_odd(n))
(n for n in numbers if test_divisibleby(n, 3))
.. versionadded:: 2.7
do_selectattr(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to the specified
attribute of each object, and only selecting the objects with the
test succeeding.
If no test is specified, the attribute's value will be evaluated as
a boolean.
Example usage:
.. sourcecode:: jinja
{{ users|selectattr("is_active") }}
{{ users|selectattr("email", "none") }}
Similar to a generator comprehension such as:
.. code-block:: python
(u for user in users if user.is_active)
(u for user in users if test_none(user.email))
.. versionadded:: 2.7
do_slice(value: 't.Collection[V]', slices: int, fill_with: 't.Optional[V]' = None) -> 't.Iterator[t.List[V]]'
Slice an iterator and return a list of lists containing
those items. Useful if you want to create a div containing
three ul tags that represent columns:
.. sourcecode:: html+jinja
<div class="columnwrapper">
{%- for column in items|slice(3) %}
<ul class="column-{{ loop.index }}">
{%- for item in column %}
<li>{{ item }}</li>
{%- endfor %}
</ul>
{%- endfor %}
</div>
If you pass it a second argument it's used to fill missing
values on the last iteration.
do_sort(environment: 'Environment', value: 't.Iterable[V]', reverse: bool = False, case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None) -> 't.List[V]'
Sort an iterable using Python's :func:`sorted`.
.. sourcecode:: jinja
{% for city in cities|sort %}
...
{% endfor %}
:param reverse: Sort descending instead of ascending.
:param case_sensitive: When sorting strings, sort upper and lower
case separately.
:param attribute: When sorting objects or dicts, an attribute or
key to sort by. Can use dot notation like ``"address.city"``.
Can be a list of attributes like ``"age,name"``.
The sort is stable, it does not change the relative order of
elements that compare equal. This makes it is possible to chain
sorts on different attributes and ordering.
.. sourcecode:: jinja
{% for user in users|sort(attribute="name")
|sort(reverse=true, attribute="age") %}
...
{% endfor %}
As a shortcut to chaining when the direction is the same for all
attributes, pass a comma separate list of attributes.
.. sourcecode:: jinja
{% for user in users|sort(attribute="age,name") %}
...
{% endfor %}
.. versionchanged:: 2.11.0
The ``attribute`` parameter can be a comma separated list of
attributes, e.g. ``"age,name"``.
.. versionchanged:: 2.6
The ``attribute`` parameter was added.
do_striptags(value: 't.Union[str, HasHTML]') -> str
Strip SGML/XML tags and replace adjacent whitespace by one space.
do_sum(environment: 'Environment', iterable: 't.Iterable[V]', attribute: Union[str, int, NoneType] = None, start: ~V = 0) -> ~V
Returns the sum of a sequence of numbers plus the value of parameter
'start' (which defaults to 0). When the sequence is empty it returns
start.
It is also possible to sum up only certain attributes:
.. sourcecode:: jinja
Total: {{ items|sum(attribute='price') }}
.. versionchanged:: 2.6
The ``attribute`` parameter was added to allow summing up over
attributes. Also the ``start`` parameter was moved on to the right.
do_title(s: str) -> str
Return a titlecased version of the value. I.e. words will start with
uppercase letters, all remaining characters are lowercase.
do_tojson(eval_ctx: 'EvalContext', value: Any, indent: Optional[int] = None) -> markupsafe.Markup
Serialize an object to a string of JSON, and mark it safe to
render in HTML. This filter is only for use in HTML documents.
The returned string is safe to render in HTML documents and
``<script>`` tags. The exception is in HTML attributes that are
double quoted; either use single quotes or the ``|forceescape``
filter.
:param value: The object to serialize to JSON.
:param indent: The ``indent`` parameter passed to ``dumps``, for
pretty-printing the value.
.. versionadded:: 2.9
do_trim(value: str, chars: Optional[str] = None) -> str
Strip leading and trailing characters, by default whitespace.
do_truncate(env: 'Environment', s: str, length: int = 255, killwords: bool = False, end: str = '...', leeway: Optional[int] = None) -> str
Return a truncated copy of the string. The length is specified
with the first parameter which defaults to ``255``. If the second
parameter is ``true`` the filter will cut the text at length. Otherwise
it will discard the last word. If the text was in fact
truncated it will append an ellipsis sign (``"..."``). If you want a
different ellipsis sign than ``"..."`` you can specify it using the
third parameter. Strings that only exceed the length by the tolerance
margin given in the fourth parameter will not be truncated.
.. sourcecode:: jinja
{{ "foo bar baz qux"|truncate(9) }}
-> "foo..."
{{ "foo bar baz qux"|truncate(9, True) }}
-> "foo ba..."
{{ "foo bar baz qux"|truncate(11) }}
-> "foo bar baz qux"
{{ "foo bar baz qux"|truncate(11, False, '...', 0) }}
-> "foo bar..."
The default leeway on newer Jinja versions is 5 and was 0 before but
can be reconfigured globally.
do_unique(environment: 'Environment', value: 't.Iterable[V]', case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None) -> 't.Iterator[V]'
Returns a list of unique items from the given iterable.
.. sourcecode:: jinja
{{ ['foo', 'bar', 'foobar', 'FooBar']|unique|list }}
-> ['foo', 'bar', 'foobar']
The unique items are yielded in the same order as their first occurrence in
the iterable passed to the filter.
:param case_sensitive: Treat upper and lower case strings as distinct.
:param attribute: Filter objects with unique values for this attribute.
do_upper(s: str) -> str
Convert a value to uppercase.
do_urlencode(value: Union[str, Mapping[str, Any], Iterable[Tuple[str, Any]]]) -> str
Quote data for use in a URL path or query using UTF-8.
Basic wrapper around :func:`urllib.parse.quote` when given a
string, or :func:`urllib.parse.urlencode` for a dict or iterable.
:param value: Data to quote. A string will be quoted directly. A
dict or iterable of ``(key, value)`` pairs will be joined as a
query string.
When given a string, "/" is not quoted. HTTP servers treat "/" and
"%2F" equivalently in paths. If you need quoted slashes, use the
``|replace("/", "%2F")`` filter.
.. versionadded:: 2.7
do_urlize(eval_ctx: 'EvalContext', value: str, trim_url_limit: Optional[int] = None, nofollow: bool = False, target: Optional[str] = None, rel: Optional[str] = None, extra_schemes: Optional[Iterable[str]] = None) -> str
Convert URLs in text into clickable links.
This may not recognize links in some situations. Usually, a more
comprehensive formatter, such as a Markdown library, is a better
choice.
Works on ``http://``, ``https://``, ``www.``, ``mailto:``, and email
addresses. Links with trailing punctuation (periods, commas, closing
parentheses) and leading punctuation (opening parentheses) are
recognized excluding the punctuation. Email addresses that include
header fields are not recognized (for example,
``mailto:address@example.com?cc=copy@example.com``).
:param value: Original text containing URLs to link.
:param trim_url_limit: Shorten displayed URL values to this length.
:param nofollow: Add the ``rel=nofollow`` attribute to links.
:param target: Add the ``target`` attribute to links.
:param rel: Add the ``rel`` attribute to links.
:param extra_schemes: Recognize URLs that start with these schemes
in addition to the default behavior. Defaults to
``env.policies["urlize.extra_schemes"]``, which defaults to no
extra schemes.
.. versionchanged:: 3.0
The ``extra_schemes`` parameter was added.
.. versionchanged:: 3.0
Generate ``https://`` links for URLs without a scheme.
.. versionchanged:: 3.0
The parsing rules were updated. Recognize email addresses with
or without the ``mailto:`` scheme. Validate IP addresses. Ignore
parentheses and brackets in more cases.
.. versionchanged:: 2.8
The ``target`` parameter was added.
do_wordcount(s: str) -> int
Count the words in that string.
do_wordwrap(environment: 'Environment', s: str, width: int = 79, break_long_words: bool = True, wrapstring: Optional[str] = None, break_on_hyphens: bool = True) -> str
Wrap a string to the given width. Existing newlines are treated
as paragraphs to be wrapped separately.
:param s: Original text to wrap.
:param width: Maximum length of wrapped lines.
:param break_long_words: If a word is longer than ``width``, break
it across lines.
:param break_on_hyphens: If a word contains hyphens, it may be split
across lines.
:param wrapstring: String to join each wrapped line. Defaults to
:attr:`Environment.newline_sequence`.
.. versionchanged:: 2.11
Existing newlines are treated as paragraphs wrapped separately.
.. versionchanged:: 2.11
Added the ``break_on_hyphens`` parameter.
.. versionchanged:: 2.7
Added the ``wrapstring`` parameter.
do_xmlattr(eval_ctx: 'EvalContext', d: Mapping[str, Any], autospace: bool = True) -> str
Create an SGML/XML attribute string based on the items in a dict.
**Values** that are neither ``none`` nor ``undefined`` are automatically
escaped, safely allowing untrusted user input.
User input should not be used as **keys** to this filter. If any key
contains a space, ``/`` solidus, ``>`` greater-than sign, or ``=`` equals
sign, this fails with a ``ValueError``. Regardless of this, user input
should never be used as keys to this filter, or must be separately validated
first.
.. sourcecode:: html+jinja
<ul{{ {'class': 'my_list', 'missing': none,
'id': 'list-%d'|format(variable)}|xmlattr }}>
...
</ul>
Results in something like this:
.. sourcecode:: html
<ul class="my_list" id="list-42">
...
</ul>
As you can see it automatically prepends a space in front of the item
if the filter returned something unless the second parameter is false.
.. versionchanged:: 3.1.4
Keys with ``/`` solidus, ``>`` greater-than sign, or ``=`` equals sign
are not allowed.
.. versionchanged:: 3.1.3
Keys with spaces are not allowed.
escape(...)
Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in the string with HTML-safe sequences. Use this if you need to display text that might contain such characters in HTML.
If the object has an ``__html__`` method, it is called and the return value is assumed to already be safe for HTML.
:param s: An object to be converted to a string and escaped.
:return: A :class:`Markup` string with the escaped text.
ignore_case(value: ~V) -> ~V
For use as a postprocessor for :func:`make_attrgetter`. Converts strings
to lowercase and returns other types as-is.
make_attrgetter(environment: 'Environment', attribute: Union[str, int, NoneType], postprocess: Optional[Callable[[Any], Any]] = None, default: Optional[Any] = None) -> Callable[[Any], Any]
Returns a callable that looks up the given attribute from a
passed object with the rules of the environment. Dots are allowed
to access attributes of attributes. Integer parts in paths are
looked up as integers.
make_multi_attrgetter(environment: 'Environment', attribute: Union[str, int, NoneType], postprocess: Optional[Callable[[Any], Any]] = None) -> Callable[[Any], List[Any]]
Returns a callable that looks up the given comma separated
attributes from a passed object with the rules of the environment.
Dots are allowed to access attributes of each attribute. Integer
parts in paths are looked up as integers.
The value returned by the returned callable is a list of extracted
attribute values.
Examples of attribute: "attr1,attr2", "attr1.inner1.0,attr2.inner2.0", etc.
prepare_map(context: 'Context', args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Callable[[Any], Any]
prepare_select_or_reject(context: 'Context', args: Tuple[Any, ...], kwargs: Dict[str, Any], modfunc: Callable[[Any], Any], lookup_attr: bool) -> Callable[[Any], Any]
select_or_reject(context: 'Context', value: 't.Iterable[V]', args: Tuple[Any, ...], kwargs: Dict[str, Any], modfunc: Callable[[Any], Any], lookup_attr: bool) -> 't.Iterator[V]'
soft_str(...)
Convert an object to a string if it isn't already. This preserves a :class:`Markup` string rather than converting it back to a basic string, so it will still be marked as safe and won't be escaped again.
>>> value = escape("<User 1>")
>>> value
Markup('<User 1>')
>>> escape(str(value))
Markup('&lt;User 1&gt;')
>>> escape(soft_str(value))
Markup('<User 1>')
sync_do_first(environment: 'Environment', seq: 't.Iterable[V]') -> 't.Union[V, Undefined]'
Return the first item of a sequence.
sync_do_groupby(environment: 'Environment', value: 't.Iterable[V]', attribute: Union[str, int], default: Optional[Any] = None, case_sensitive: bool = False) -> 't.List[_GroupTuple]'
Group a sequence of objects by an attribute using Python's
:func:`itertools.groupby`. The attribute can use dot notation for
nested access, like ``"address.city"``. Unlike Python's ``groupby``,
the values are sorted first so only one group is returned for each
unique value.
For example, a list of ``User`` objects with a ``city`` attribute
can be rendered in groups. In this example, ``grouper`` refers to
the ``city`` value of the group.
.. sourcecode:: html+jinja
<ul>{% for city, items in users|groupby("city") %}
<li>{{ city }}
<ul>{% for user in items %}
<li>{{ user.name }}
{% endfor %}</ul>
</li>
{% endfor %}</ul>
``groupby`` yields namedtuples of ``(grouper, list)``, which
can be used instead of the tuple unpacking above. ``grouper`` is the
value of the attribute, and ``list`` is the items with that value.
.. sourcecode:: html+jinja
<ul>{% for group in users|groupby("city") %}
<li>{{ group.grouper }}: {{ group.list|join(", ") }}
{% endfor %}</ul>
You can specify a ``default`` value to use if an object in the list
does not have the given attribute.
.. sourcecode:: jinja
<ul>{% for city, items in users|groupby("city", default="NY") %}
<li>{{ city }}: {{ items|map(attribute="name")|join(", ") }}</li>
{% endfor %}</ul>
Like the :func:`~jinja-filters.sort` filter, sorting and grouping is
case-insensitive by default. The ``key`` for each group will have
the case of the first item in that group of values. For example, if
a list of users has cities ``["CA", "NY", "ca"]``, the "CA" group
will have two values. This can be disabled by passing
``case_sensitive=True``.
.. versionchanged:: 3.1
Added the ``case_sensitive`` parameter. Sorting and grouping is
case-insensitive by default, matching other filters that do
comparisons.
.. versionchanged:: 3.0
Added the ``default`` parameter.
.. versionchanged:: 2.6
The attribute supports dot notation for nested access.
sync_do_join(eval_ctx: 'EvalContext', value: Iterable[Any], d: str = '', attribute: Union[str, int, NoneType] = None) -> str
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is an empty string per
default, you can define it with the optional parameter:
.. sourcecode:: jinja
{{ [1, 2, 3]|join('|') }}
-> 1|2|3
{{ [1, 2, 3]|join }}
-> 123
It is also possible to join certain attributes of an object:
.. sourcecode:: jinja
{{ users|join(', ', attribute='username') }}
.. versionadded:: 2.6
The `attribute` parameter was added.
sync_do_list(value: 't.Iterable[V]') -> 't.List[V]'
Convert the value into a list. If it was a string the returned list
will be a list of characters.
sync_do_map(context: 'Context', value: Iterable[Any], *args: Any, **kwargs: Any) -> Iterable[Any]
Applies a filter on a sequence of objects or looks up an attribute.
This is useful when dealing with lists of objects but you are really
only interested in a certain value of it.
The basic usage is mapping on an attribute. Imagine you have a list
of users but you are only interested in a list of usernames:
.. sourcecode:: jinja
Users on this page: {{ users|map(attribute='username')|join(', ') }}
You can specify a ``default`` value to use if an object in the list
does not have the given attribute.
.. sourcecode:: jinja
{{ users|map(attribute="username", default="Anonymous")|join(", ") }}
Alternatively you can let it invoke a filter by passing the name of the
filter and the arguments afterwards. A good example would be applying a
text conversion filter on a sequence:
.. sourcecode:: jinja
Users on this page: {{ titles|map('lower')|join(', ') }}
Similar to a generator comprehension such as:
.. code-block:: python
(u.username for u in users)
(getattr(u, "username", "Anonymous") for u in users)
(do_lower(x) for x in titles)
.. versionchanged:: 2.11.0
Added the ``default`` parameter.
.. versionadded:: 2.7
sync_do_reject(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to each object,
and rejecting the objects with the test succeeding.
If no test is specified, each object will be evaluated as a boolean.
Example usage:
.. sourcecode:: jinja
{{ numbers|reject("odd") }}
Similar to a generator comprehension such as:
.. code-block:: python
(n for n in numbers if not test_odd(n))
.. versionadded:: 2.7
sync_do_rejectattr(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to the specified
attribute of each object, and rejecting the objects with the test
succeeding.
If no test is specified, the attribute's value will be evaluated as
a boolean.
.. sourcecode:: jinja
{{ users|rejectattr("is_active") }}
{{ users|rejectattr("email", "none") }}
Similar to a generator comprehension such as:
.. code-block:: python
(u for user in users if not user.is_active)
(u for user in users if not test_none(user.email))
.. versionadded:: 2.7
sync_do_select(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to each object,
and only selecting the objects with the test succeeding.
If no test is specified, each object will be evaluated as a boolean.
Example usage:
.. sourcecode:: jinja
{{ numbers|select("odd") }}
{{ numbers|select("odd") }}
{{ numbers|select("divisibleby", 3) }}
{{ numbers|select("lessthan", 42) }}
{{ strings|select("equalto", "mystring") }}
Similar to a generator comprehension such as:
.. code-block:: python
(n for n in numbers if test_odd(n))
(n for n in numbers if test_divisibleby(n, 3))
.. versionadded:: 2.7
sync_do_selectattr(context: 'Context', value: 't.Iterable[V]', *args: Any, **kwargs: Any) -> 't.Iterator[V]'
Filters a sequence of objects by applying a test to the specified
attribute of each object, and only selecting the objects with the
test succeeding.
If no test is specified, the attribute's value will be evaluated as
a boolean.
Example usage:
.. sourcecode:: jinja
{{ users|selectattr("is_active") }}
{{ users|selectattr("email", "none") }}
Similar to a generator comprehension such as:
.. code-block:: python
(u for user in users if user.is_active)
(u for user in users if test_none(user.email))
.. versionadded:: 2.7
sync_do_slice(value: 't.Collection[V]', slices: int, fill_with: 't.Optional[V]' = None) -> 't.Iterator[t.List[V]]'
Slice an iterator and return a list of lists containing
those items. Useful if you want to create a div containing
three ul tags that represent columns:
.. sourcecode:: html+jinja
<div class="columnwrapper">
{%- for column in items|slice(3) %}
<ul class="column-{{ loop.index }}">
{%- for item in column %}
<li>{{ item }}</li>
{%- endfor %}
</ul>
{%- endfor %}
</div>
If you pass it a second argument it's used to fill missing
values on the last iteration.
sync_do_sum(environment: 'Environment', iterable: 't.Iterable[V]', attribute: Union[str, int, NoneType] = None, start: ~V = 0) -> ~V
Returns the sum of a sequence of numbers plus the value of parameter
'start' (which defaults to 0). When the sequence is empty it returns
start.
It is also possible to sum up only certain attributes:
.. sourcecode:: jinja
Total: {{ items|sum(attribute='price') }}
.. versionchanged:: 2.6
The ``attribute`` parameter was added to allow summing up over
attributes. Also the ``start`` parameter was moved on to the right.
DATA
F = ~F
FILTERS = {'abs': <built-in function abs>, 'attr': <function do_attr>,...
K = ~K
V = ~V
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\filters.py
jinja2.idtracking
Python Library Documentation: module jinja2.idtracking in jinja2
NAME
jinja2.idtracking
CLASSES
builtins.object
Symbols
jinja2.visitor.NodeVisitor(builtins.object)
FrameSymbolVisitor
RootVisitor
class FrameSymbolVisitor(jinja2.visitor.NodeVisitor)
| FrameSymbolVisitor(symbols: 'Symbols') -> None
|
| A visitor for `Frame.inspect`.
|
| Method resolution order:
| FrameSymbolVisitor
| jinja2.visitor.NodeVisitor
| builtins.object
|
| Methods defined here:
|
| __init__(self, symbols: 'Symbols') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| visit_Assign(self, node: jinja2.nodes.Assign, **kwargs: Any) -> None
| Visit assignments in the correct order.
|
| visit_AssignBlock(self, node: jinja2.nodes.AssignBlock, **kwargs: Any) -> None
| Stop visiting at block assigns.
|
| visit_Block(self, node: jinja2.nodes.Block, **kwargs: Any) -> None
| Stop visiting at blocks.
|
| visit_CallBlock(self, node: jinja2.nodes.CallBlock, **kwargs: Any) -> None
|
| visit_FilterBlock(self, node: jinja2.nodes.FilterBlock, **kwargs: Any) -> None
|
| visit_For(self, node: jinja2.nodes.For, **kwargs: Any) -> None
| Visiting stops at for blocks. However the block sequence
| is visited as part of the outer scope.
|
| visit_FromImport(self, node: jinja2.nodes.FromImport, **kwargs: Any) -> None
|
| visit_If(self, node: jinja2.nodes.If, **kwargs: Any) -> None
|
| visit_Import(self, node: jinja2.nodes.Import, **kwargs: Any) -> None
|
| visit_Macro(self, node: jinja2.nodes.Macro, **kwargs: Any) -> None
|
| visit_NSRef(self, node: jinja2.nodes.NSRef, **kwargs: Any) -> None
|
| visit_Name(self, node: jinja2.nodes.Name, store_as_param: bool = False, **kwargs: Any) -> None
| All assignments to names go through this function.
|
| visit_OverlayScope(self, node: jinja2.nodes.OverlayScope, **kwargs: Any) -> None
| Do not visit into overlay scopes.
|
| visit_Scope(self, node: jinja2.nodes.Scope, **kwargs: Any) -> None
| Stop visiting at scopes.
|
| visit_With(self, node: jinja2.nodes.With, **kwargs: Any) -> None
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from jinja2.visitor.NodeVisitor:
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Called if no explicit visitor function exists for a node.
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from jinja2.visitor.NodeVisitor:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class RootVisitor(jinja2.visitor.NodeVisitor)
| RootVisitor(symbols: 'Symbols') -> None
|
| Method resolution order:
| RootVisitor
| jinja2.visitor.NodeVisitor
| builtins.object
|
| Methods defined here:
|
| __init__(self, symbols: 'Symbols') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> None
| Called if no explicit visitor function exists for a node.
|
| visit_AssignBlock(self, node: jinja2.nodes.AssignBlock, **kwargs: Any) -> None
|
| visit_Block = _simple_visit(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| visit_CallBlock(self, node: jinja2.nodes.CallBlock, **kwargs: Any) -> None
|
| visit_FilterBlock = _simple_visit(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| visit_For(self, node: jinja2.nodes.For, for_branch: str = 'body', **kwargs: Any) -> None
|
| visit_If = _simple_visit(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| visit_Macro = _simple_visit(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| visit_OverlayScope(self, node: jinja2.nodes.OverlayScope, **kwargs: Any) -> None
|
| visit_Scope = _simple_visit(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| visit_ScopedEvalContextModifier = _simple_visit(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| visit_Template = _simple_visit(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| visit_With(self, node: jinja2.nodes.With, **kwargs: Any) -> None
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from jinja2.visitor.NodeVisitor:
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from jinja2.visitor.NodeVisitor:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Symbols(builtins.object)
| Symbols(parent: Optional[ForwardRef('Symbols')] = None, level: Optional[int] = None) -> None
|
| Methods defined here:
|
| __init__(self, parent: Optional[ForwardRef('Symbols')] = None, level: Optional[int] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| analyze_node(self, node: jinja2.nodes.Node, **kwargs: Any) -> None
|
| branch_update(self, branch_symbols: Sequence[ForwardRef('Symbols')]) -> None
|
| copy(self) -> 'Symbols'
|
| declare_parameter(self, name: str) -> str
|
| dump_param_targets(self) -> Set[str]
|
| dump_stores(self) -> Dict[str, str]
|
| find_load(self, target: str) -> Optional[Any]
|
| find_ref(self, name: str) -> Optional[str]
|
| load(self, name: str) -> None
|
| ref(self, name: str) -> str
|
| store(self, name: str) -> None
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
find_symbols(nodes: Iterable[jinja2.nodes.Node], parent_symbols: Optional[ForwardRef('Symbols')] = None) -> 'Symbols'
symbols_for_node(node: jinja2.nodes.Node, parent_symbols: Optional[ForwardRef('Symbols')] = None) -> 'Symbols'
DATA
VAR_LOAD_ALIAS = 'alias'
VAR_LOAD_PARAMETER = 'param'
VAR_LOAD_RESOLVE = 'resolve'
VAR_LOAD_UNDEFINED = 'undefined'
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\idtracking.py
jinja2.is_undefined
Python Library Documentation: function is_undefined in module jinja2.utils
is_undefined(obj: Any) -> bool
Check if the object passed is undefined. This does nothing more than
performing an instance check against :class:`Undefined` but looks nicer.
This can be used for custom filters or tests that want to react to
undefined variables. For example a custom default filter can look like
this::
def default(var, default=''):
if is_undefined(var):
return default
return var
jinja2.lexer
Python Library Documentation: module jinja2.lexer in jinja2
NAME
jinja2.lexer
DESCRIPTION
Implements a Jinja / Python combination lexer. The ``Lexer`` class
is used to do some preprocessing. It filters out invalid operators like
the bitshift operators we don't allow in templates. It separates
template code and python code in expressions.
CLASSES
builtins.object
Failure
Lexer
TokenStream
TokenStreamIterator
builtins.tuple(builtins.object)
OptionalLStrip
Token
class Failure(builtins.object)
| Failure(message: str, cls: Type[jinja2.exceptions.TemplateSyntaxError] = <class 'jinja2.exceptions.TemplateSyntaxError'>) -> None
|
| Class that raises a `TemplateSyntaxError` if called.
| Used by the `Lexer` to specify known errors.
|
| Methods defined here:
|
| __call__(self, lineno: int, filename: str) -> 'te.NoReturn'
| Call self as a function.
|
| __init__(self, message: str, cls: Type[jinja2.exceptions.TemplateSyntaxError] = <class 'jinja2.exceptions.TemplateSyntaxError'>) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Lexer(builtins.object)
| Lexer(environment: 'Environment') -> None
|
| Class that implements a lexer for a given environment. Automatically
| created by the environment class, usually you don't have to do that.
|
| Note that the lexer is not automatically bound to an environment.
| Multiple environments can share the same lexer.
|
| Methods defined here:
|
| __init__(self, environment: 'Environment') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| tokeniter(self, source: str, name: Optional[str], filename: Optional[str] = None, state: Optional[str] = None) -> Iterator[Tuple[int, str, str]]
| This method tokenizes the text and returns the tokens in a
| generator. Use this method if you just want to tokenize a template.
|
| .. versionchanged:: 3.0
| Only ``\n``, ``\r\n`` and ``\r`` are treated as line
| breaks.
|
| tokenize(self, source: str, name: Optional[str] = None, filename: Optional[str] = None, state: Optional[str] = None) -> jinja2.lexer.TokenStream
| Calls tokeniter + tokenize and wraps it in a token stream.
|
| wrap(self, stream: Iterable[Tuple[int, str, str]], name: Optional[str] = None, filename: Optional[str] = None) -> Iterator[jinja2.lexer.Token]
| This is called with the stream as returned by `tokenize` and wraps
| every token in a :class:`Token` and converts the value.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class OptionalLStrip(builtins.tuple)
| OptionalLStrip(*members, **kwargs)
|
| A special tuple for marking a point in the state that can have
| lstrip applied.
|
| Method resolution order:
| OptionalLStrip
| builtins.tuple
| builtins.object
|
| Static methods defined here:
|
| __new__(cls, *members, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class Token(builtins.tuple)
| Token(lineno: int, type: str, value: str)
|
| Token(lineno, type, value)
|
| Method resolution order:
| Token
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.Token
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.Token
| Return a nicely formatted representation string
|
| __str__(self) -> str
| Return str(self).
|
| _asdict(self) from collections.Token
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.Token
| Return a new Token object replacing specified fields with new values
|
| test(self, expr: str) -> bool
| Test a token against a token expression. This can either be a
| token type or ``'token_type:token_value'``. This can only test
| against string values and types.
|
| test_any(self, *iterable: str) -> bool
| Test against multiple token expressions.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.Token
| Make a new Token object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, lineno: int, type: str, value: str) from namedtuple_Token.Token
| Create new instance of Token(lineno, type, value)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| lineno
| Alias for field number 0
|
| type
| Alias for field number 1
|
| value
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'lineno': <class 'int'>, 'type': <class 'str'>, 'va...
|
| __match_args__ = ('lineno', 'type', 'value')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('lineno', 'type', 'value')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class TokenStream(builtins.object)
| TokenStream(generator: Iterable[jinja2.lexer.Token], name: Optional[str], filename: Optional[str])
|
| A token stream is an iterable that yields :class:`Token`\s. The
| parser however does not iterate over it but calls :meth:`next` to go
| one token ahead. The current active token is stored as :attr:`current`.
|
| Methods defined here:
|
| __bool__(self) -> bool
|
| __init__(self, generator: Iterable[jinja2.lexer.Token], name: Optional[str], filename: Optional[str])
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self) -> jinja2.lexer.TokenStreamIterator
|
| __next__(self) -> jinja2.lexer.Token
| Go one token ahead and return the old one.
|
| Use the built-in :func:`next` instead of calling this directly.
|
| close(self) -> None
| Close the stream.
|
| expect(self, expr: str) -> jinja2.lexer.Token
| Expect a given token type and return it. This accepts the same
| argument as :meth:`jinja2.lexer.Token.test`.
|
| look(self) -> jinja2.lexer.Token
| Look at the next token.
|
| next_if(self, expr: str) -> Optional[jinja2.lexer.Token]
| Perform the token test and return the token if it matched.
| Otherwise the return value is `None`.
|
| push(self, token: jinja2.lexer.Token) -> None
| Push a token back to the stream.
|
| skip(self, n: int = 1) -> None
| Got n tokens ahead.
|
| skip_if(self, expr: str) -> bool
| Like :meth:`next_if` but only returns `True` or `False`.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| eos
| Are we at the end of the stream?
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class TokenStreamIterator(builtins.object)
| TokenStreamIterator(stream: 'TokenStream') -> None
|
| The iterator for tokenstreams. Iterate over the stream
| until the eof token is reached.
|
| Methods defined here:
|
| __init__(self, stream: 'TokenStream') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self) -> 'TokenStreamIterator'
|
| __next__(self) -> jinja2.lexer.Token
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
compile_rules(environment: 'Environment') -> List[Tuple[str, str]]
Compiles all the rules from the environment into a list of rules.
count_newlines(value: str) -> int
Count the number of newline characters in the string. This is
useful for extensions that filter a stream.
describe_token(token: 'Token') -> str
Returns a description of the token.
describe_token_expr(expr: str) -> str
Like `describe_token` but for token expressions.
get_lexer(environment: 'Environment') -> 'Lexer'
Return a lexer which is probably cached.
intern(string, /)
``Intern'' the given string.
This enters the string in the (global) table of interned strings whose
purpose is to speed up dictionary lookups. Return the string itself or
the previously interned string object with the same value.
DATA
TOKEN_ADD = 'add'
TOKEN_ASSIGN = 'assign'
TOKEN_BLOCK_BEGIN = 'block_begin'
TOKEN_BLOCK_END = 'block_end'
TOKEN_COLON = 'colon'
TOKEN_COMMA = 'comma'
TOKEN_COMMENT = 'comment'
TOKEN_COMMENT_BEGIN = 'comment_begin'
TOKEN_COMMENT_END = 'comment_end'
TOKEN_DATA = 'data'
TOKEN_DIV = 'div'
TOKEN_DOT = 'dot'
TOKEN_EOF = 'eof'
TOKEN_EQ = 'eq'
TOKEN_FLOAT = 'float'
TOKEN_FLOORDIV = 'floordiv'
TOKEN_GT = 'gt'
TOKEN_GTEQ = 'gteq'
TOKEN_INITIAL = 'initial'
TOKEN_INTEGER = 'integer'
TOKEN_LBRACE = 'lbrace'
TOKEN_LBRACKET = 'lbracket'
TOKEN_LINECOMMENT = 'linecomment'
TOKEN_LINECOMMENT_BEGIN = 'linecomment_begin'
TOKEN_LINECOMMENT_END = 'linecomment_end'
TOKEN_LINESTATEMENT_BEGIN = 'linestatement_begin'
TOKEN_LINESTATEMENT_END = 'linestatement_end'
TOKEN_LPAREN = 'lparen'
TOKEN_LT = 'lt'
TOKEN_LTEQ = 'lteq'
TOKEN_MOD = 'mod'
TOKEN_MUL = 'mul'
TOKEN_NAME = 'name'
TOKEN_NE = 'ne'
TOKEN_OPERATOR = 'operator'
TOKEN_PIPE = 'pipe'
TOKEN_POW = 'pow'
TOKEN_RAW_BEGIN = 'raw_begin'
TOKEN_RAW_END = 'raw_end'
TOKEN_RBRACE = 'rbrace'
TOKEN_RBRACKET = 'rbracket'
TOKEN_RPAREN = 'rparen'
TOKEN_SEMICOLON = 'semicolon'
TOKEN_STRING = 'string'
TOKEN_SUB = 'sub'
TOKEN_TILDE = 'tilde'
TOKEN_VARIABLE_BEGIN = 'variable_begin'
TOKEN_VARIABLE_END = 'variable_end'
TOKEN_WHITESPACE = 'whitespace'
__annotations__ = {'_lexer_cache': typing.MutableMapping[typing.Tuple,...
float_re = re.compile("\n (?<!\\.) # doesn't start with...)*\\d+ ...
ignore_if_empty = frozenset({'comment', 'data', 'linecomment', 'whites...
ignored_tokens = frozenset({'comment', 'comment_begin', 'comment_end',...
integer_re = re.compile('\n (\n 0b(_?[0-1])+ # bina... # dec...
name_re = re.compile('[\\w·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-ٰٟۖ-ۜ۟-ۤۧۨ...ூெ-ைொ-்ௗఀ...
newline_re = re.compile('(\\r\\n|\\r|\\n)')
operator_re = re.compile('(//|\\*\\*|==|!=|>=|<=|\\+|\\-|/|\\*...\~|\\...
operators = {'!=': 'ne', '%': 'mod', '(': 'lparen', ')': 'rparen', '*'...
reverse_operators = {'add': '+', 'assign': '=', 'colon': ':', 'comma':...
string_re = re.compile('(\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'|"([^"\\\...
whitespace_re = re.compile('\\s+')
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\lexer.py
jinja2.loaders
Python Library Documentation: module jinja2.loaders in jinja2
NAME
jinja2.loaders
DESCRIPTION
API and implementations for loading templates from different data
sources.
CLASSES
builtins.object
BaseLoader
ChoiceLoader
DictLoader
FileSystemLoader
FunctionLoader
ModuleLoader
PackageLoader
PrefixLoader
class BaseLoader(builtins.object)
| Baseclass for all loaders. Subclass this and override `get_source` to
| implement a custom loading mechanism. The environment provides a
| `get_template` method that calls the loader's `load` method to get the
| :class:`Template` object.
|
| A very basic example for a loader that looks up templates on the file
| system could look like this::
|
| from jinja2 import BaseLoader, TemplateNotFound
| from os.path import join, exists, getmtime
|
| class MyLoader(BaseLoader):
|
| def __init__(self, path):
| self.path = path
|
| def get_source(self, environment, template):
| path = join(self.path, template)
| if not exists(path):
| raise TemplateNotFound(template)
| mtime = getmtime(path)
| with open(path) as f:
| source = f.read()
| return source, path, lambda: mtime == getmtime(path)
|
| Methods defined here:
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_source_access = True
class ChoiceLoader(BaseLoader)
| ChoiceLoader(loaders: Sequence[jinja2.loaders.BaseLoader]) -> None
|
| This loader works like the `PrefixLoader` just that no prefix is
| specified. If a template could not be found by one loader the next one
| is tried.
|
| >>> loader = ChoiceLoader([
| ... FileSystemLoader('/path/to/user/templates'),
| ... FileSystemLoader('/path/to/system/templates')
| ... ])
|
| This is useful if you want to allow users to override builtin templates
| from a different location.
|
| Method resolution order:
| ChoiceLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, loaders: Sequence[jinja2.loaders.BaseLoader]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
class DictLoader(BaseLoader)
| DictLoader(mapping: Mapping[str, str]) -> None
|
| Loads a template from a Python dict mapping template names to
| template source. This loader is useful for unittesting:
|
| >>> loader = DictLoader({'index.html': 'source here'})
|
| Because auto reloading is rarely useful this is disabled per default.
|
| Method resolution order:
| DictLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, mapping: Mapping[str, str]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, NoneType, Callable[[], bool]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
class FileSystemLoader(BaseLoader)
| FileSystemLoader(searchpath: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]], encoding: str = 'utf-8', followlinks: bool = False) -> None
|
| Load templates from a directory in the file system.
|
| The path can be relative or absolute. Relative paths are relative to
| the current working directory.
|
| .. code-block:: python
|
| loader = FileSystemLoader("templates")
|
| A list of paths can be given. The directories will be searched in
| order, stopping at the first matching template.
|
| .. code-block:: python
|
| loader = FileSystemLoader(["/override/templates", "/default/templates"])
|
| :param searchpath: A path, or list of paths, to the directory that
| contains the templates.
| :param encoding: Use this encoding to read the text from template
| files.
| :param followlinks: Follow symbolic links in the path.
|
| .. versionchanged:: 2.8
| Added the ``followlinks`` parameter.
|
| Method resolution order:
| FileSystemLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, searchpath: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]], encoding: str = 'utf-8', followlinks: bool = False) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, str, Callable[[], bool]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
class FunctionLoader(BaseLoader)
| FunctionLoader(load_func: Callable[[str], Union[str, Tuple[str, Optional[str], Optional[Callable[[], bool]]], NoneType]]) -> None
|
| A loader that is passed a function which does the loading. The
| function receives the name of the template and has to return either
| a string with the template source, a tuple in the form ``(source,
| filename, uptodatefunc)`` or `None` if the template does not exist.
|
| >>> def load_template(name):
| ... if name == 'index.html':
| ... return '...'
| ...
| >>> loader = FunctionLoader(load_template)
|
| The `uptodatefunc` is a function that is called if autoreload is enabled
| and has to return `True` if the template is still up to date. For more
| details have a look at :meth:`BaseLoader.get_source` which has the same
| return value.
|
| Method resolution order:
| FunctionLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, load_func: Callable[[str], Union[str, Tuple[str, Optional[str], Optional[Callable[[], bool]]], NoneType]]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
class ModuleLoader(BaseLoader)
| ModuleLoader(path: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]]) -> None
|
| This loader loads templates from precompiled templates.
|
| Example usage:
|
| >>> loader = ChoiceLoader([
| ... ModuleLoader('/path/to/compiled/templates'),
| ... FileSystemLoader('/path/to/templates')
| ... ])
|
| Templates can be precompiled with :meth:`Environment.compile_templates`.
|
| Method resolution order:
| ModuleLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, path: Union[str, ForwardRef('os.PathLike[str]'), Sequence[Union[str, ForwardRef('os.PathLike[str]')]]]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| get_module_filename(name: str) -> str
|
| get_template_key(name: str) -> str
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_source_access = False
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class PackageLoader(BaseLoader)
| PackageLoader(package_name: str, package_path: 'str' = 'templates', encoding: str = 'utf-8') -> None
|
| Load templates from a directory in a Python package.
|
| :param package_name: Import name of the package that contains the
| template directory.
| :param package_path: Directory within the imported package that
| contains the templates.
| :param encoding: Encoding of template files.
|
| The following example looks up templates in the ``pages`` directory
| within the ``project.ui`` package.
|
| .. code-block:: python
|
| loader = PackageLoader("project.ui", "pages")
|
| Only packages installed as directories (standard pip behavior) or
| zip/egg files (less common) are supported. The Python API for
| introspecting data in packages is too limited to support other
| installation methods the way this loader requires.
|
| There is limited support for :pep:`420` namespace packages. The
| template directory is assumed to only be in one namespace
| contributor. Zip files contributing to a namespace are not
| supported.
|
| .. versionchanged:: 3.0
| No longer uses ``setuptools`` as a dependency.
|
| .. versionchanged:: 3.0
| Limited PEP 420 namespace package support.
|
| Method resolution order:
| PackageLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, package_name: str, package_path: 'str' = 'templates', encoding: str = 'utf-8') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, str, Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseLoader:
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
class PrefixLoader(BaseLoader)
| PrefixLoader(mapping: Mapping[str, jinja2.loaders.BaseLoader], delimiter: str = '/') -> None
|
| A loader that is passed a dict of loaders where each loader is bound
| to a prefix. The prefix is delimited from the template by a slash per
| default, which can be changed by setting the `delimiter` argument to
| something else::
|
| loader = PrefixLoader({
| 'app1': PackageLoader('mypackage.app1'),
| 'app2': PackageLoader('mypackage.app2')
| })
|
| By loading ``'app1/index.html'`` the file from the app1 package is loaded,
| by loading ``'app2/index.html'`` the file from the second.
|
| Method resolution order:
| PrefixLoader
| BaseLoader
| builtins.object
|
| Methods defined here:
|
| __init__(self, mapping: Mapping[str, jinja2.loaders.BaseLoader], delimiter: str = '/') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| get_loader(self, template: str) -> Tuple[jinja2.loaders.BaseLoader, str]
|
| get_source(self, environment: 'Environment', template: str) -> Tuple[str, Optional[str], Optional[Callable[[], bool]]]
| Get the template source, filename and reload helper for a template.
| It's passed the environment and template name and has to return a
| tuple in the form ``(source, filename, uptodate)`` or raise a
| `TemplateNotFound` error if it can't locate the template.
|
| The source part of the returned tuple must be the source of the
| template as a string. The filename should be the name of the
| file on the filesystem if it was loaded from there, otherwise
| ``None``. The filename is used by Python for the tracebacks
| if no loader extension is used.
|
| The last item in the tuple is the `uptodate` function. If auto
| reloading is enabled it's always called to check if the template
| changed. No arguments are passed so the function must store the
| old state somewhere (for example in a closure). If it returns `False`
| the template will be reloaded.
|
| list_templates(self) -> List[str]
| Iterates over all templates. If the loader does not support that
| it should raise a :exc:`TypeError` which is the default behavior.
|
| load(self, environment: 'Environment', name: str, globals: Optional[MutableMapping[str, Any]] = None) -> 'Template'
| Loads a template. This method looks up the template in the cache
| or loads one by calling :meth:`get_source`. Subclasses should not
| override this method as loaders working on collections of other
| loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
| will not call this method but `get_source` directly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseLoader:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseLoader:
|
| has_source_access = True
FUNCTIONS
sha1 = openssl_sha1(string=b'', *, usedforsecurity=True)
Returns a sha1 hash object; optionally initialized with a string
split_template_path(template: str) -> List[str]
Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\loaders.py
jinja2.make_logging_undefined
Python Library Documentation: function make_logging_undefined in module jinja2.runtime
make_logging_undefined(logger: Optional[ForwardRef('logging.Logger')] = None, base: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>) -> Type[jinja2.runtime.Undefined]
Given a logger object this returns a new undefined class that will
log certain failures. It will log iterations and printing. If no
logger is given a default logger is created.
Example::
logger = logging.getLogger(__name__)
LoggingUndefined = make_logging_undefined(
logger=logger,
base=Undefined
)
.. versionadded:: 2.8
:param logger: the logger to use. If not provided, a default logger
is created.
:param base: the base class to add logging functionality to. This
defaults to :class:`Undefined`.
jinja2.nodes
Python Library Documentation: module jinja2.nodes in jinja2
NAME
jinja2.nodes
DESCRIPTION
AST nodes generated by the parser for the compiler. Also provides
some node tree helper functions used by the parser and compiler in order
to normalize nodes.
CLASSES
builtins.Exception(builtins.BaseException)
Impossible
builtins.object
EvalContext
Node
Expr
BinExpr
Add
And
Div
FloorDiv
Mod
Mul
Or
Pow
Sub
Call
Compare
Concat
CondExpr
ContextReference
DerivedContextReference
EnvironmentAttribute
ExtensionAttribute
Getattr
Getitem
ImportedName
InternalName
Literal
Const
Dict
List
TemplateData
Tuple
MarkSafe
MarkSafeIfAutoescape
NSRef
Name
Slice
UnaryExpr
Neg
Not
Pos
Helper
Keyword
Operand
Pair
Stmt
Assign
AssignBlock
Block
Break
CallBlock
Continue
EvalContextModifier
ScopedEvalContextModifier
ExprStmt
Extends
FilterBlock
For
FromImport
If
Import
Include
Macro
Output
OverlayScope
Scope
With
Template
builtins.type(builtins.object)
NodeType
_FilterTestCommon(Expr)
Filter
Test
class Add(BinExpr)
| Add(*fields: Any, **attributes: Any) -> None
|
| Add the left to the right node.
|
| Method resolution order:
| Add
| BinExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = '+'
|
| ----------------------------------------------------------------------
| Methods inherited from BinExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class And(BinExpr)
| And(*fields: Any, **attributes: Any) -> None
|
| Short circuited AND.
|
| Method resolution order:
| And
| BinExpr
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = 'and'
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Assign(Stmt)
| Assign(*fields: Any, **attributes: Any) -> None
|
| Assigns an expression to a target.
|
| Method resolution order:
| Assign
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'node': <class 'jinja2.nodes.Node'>, 'target': 'Exp...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('target', 'node')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class AssignBlock(Stmt)
| AssignBlock(*fields: Any, **attributes: Any) -> None
|
| Assigns a block to a target.
|
| Method resolution order:
| AssignBlock
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node], 'filter': t...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('target', 'filter', 'body')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class BinExpr(Expr)
| BinExpr(*fields: Any, **attributes: Any) -> None
|
| Baseclass for all binary expressions.
|
| Method resolution order:
| BinExpr
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'left': <class 'jinja2.nodes.Expr'>, 'operator': <c...
|
| abstract = True
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Block(Stmt)
| Block(*fields: Any, **attributes: Any) -> None
|
| A node that represents a block.
|
| .. versionchanged:: 3.0.0
| the `required` field was added.
|
| Method resolution order:
| Block
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node], 'name': <cl...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('name', 'body', 'scoped', 'required')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Break(Stmt)
| Break(*fields: Any, **attributes: Any) -> None
|
| Break a loop.
|
| Method resolution order:
| Break
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Call(Expr)
| Call(*fields: Any, **attributes: Any) -> None
|
| Calls an expression. `args` is a list of arguments, `kwargs` a list
| of keyword arguments (list of :class:`Keyword` nodes), and `dyn_args`
| and `dyn_kwargs` has to be either `None` or a node that is used as
| node for dynamic positional (``*args``) or keyword (``**kwargs``)
| arguments.
|
| Method resolution order:
| Call
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'args': typing.List[jinja2.nodes.Expr], 'dyn_args':...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class CallBlock(Stmt)
| CallBlock(*fields: Any, **attributes: Any) -> None
|
| Like a macro without a name but a call instead. `call` is called with
| the unnamed macro as `caller` argument this node holds.
|
| Method resolution order:
| CallBlock
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'args': typing.List[ForwardRef('Name')], 'body': ty...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('call', 'args', 'defaults', 'body')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Compare(Expr)
| Compare(*fields: Any, **attributes: Any) -> None
|
| Compares an expression with some other expressions. `ops` must be a
| list of :class:`Operand`\s.
|
| Method resolution order:
| Compare
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'expr': <class 'jinja2.nodes.Expr'>, 'ops': typing....
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('expr', 'ops')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Concat(Expr)
| Concat(*fields: Any, **attributes: Any) -> None
|
| Concatenates the list of expressions provided after converting
| them to strings.
|
| Method resolution order:
| Concat
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> str
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'nodes': typing.List[jinja2.nodes.Expr]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('nodes',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class CondExpr(Expr)
| CondExpr(*fields: Any, **attributes: Any) -> None
|
| A conditional expression (inline if expression). (``{{
| foo if bar else baz }}``)
|
| Method resolution order:
| CondExpr
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'expr1': <class 'jinja2.nodes.Expr'>, 'expr2': typi...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('test', 'expr1', 'expr2')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Const(Literal)
| Const(*fields: Any, **attributes: Any) -> None
|
| All constant values. The parser will return this node for simple
| constants such as ``42`` or ``"foo"`` but it can be used to store more
| complex values such as lists too. Only constants with a safe
| representation (objects where ``eval(repr(x)) == x`` is true).
|
| Method resolution order:
| Const
| Literal
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_untrusted(value: Any, lineno: Optional[int] = None, environment: 't.Optional[Environment]' = None) -> 'Const'
| Return a const object if the value is representable as
| constant value in the generated code, otherwise it will raise
| an `Impossible` exception.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'value': typing.Any}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('value',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ContextReference(Expr)
| ContextReference(*fields: Any, **attributes: Any) -> None
|
| Returns the current template context. It can be used like a
| :class:`Name` node, with a ``'load'`` ctx and will return the
| current :class:`~jinja2.runtime.Context` object.
|
| Here an example that assigns the current template name to a
| variable named `foo`::
|
| Assign(Name('foo', ctx='store'),
| Getattr(ContextReference(), 'name'))
|
| This is basically equivalent to using the
| :func:`~jinja2.pass_context` decorator when using the high-level
| API, which causes a reference to the context to be passed as the
| first argument to a function.
|
| Method resolution order:
| ContextReference
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Continue(Stmt)
| Continue(*fields: Any, **attributes: Any) -> None
|
| Continue a loop.
|
| Method resolution order:
| Continue
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class DerivedContextReference(Expr)
| DerivedContextReference(*fields: Any, **attributes: Any) -> None
|
| Return the current template context including locals. Behaves
| exactly like :class:`ContextReference`, but includes local
| variables, such as from a ``for`` loop.
|
| .. versionadded:: 2.11
|
| Method resolution order:
| DerivedContextReference
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Dict(Literal)
| Dict(*fields: Any, **attributes: Any) -> None
|
| Any dict literal such as ``{1: 2, 3: 4}``. The items must be a list of
| :class:`Pair` nodes.
|
| Method resolution order:
| Dict
| Literal
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Dict[Any, Any]
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'items': typing.List[ForwardRef('Pair')]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('items',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Div(BinExpr)
| Div(*fields: Any, **attributes: Any) -> None
|
| Divides the left by the right node.
|
| Method resolution order:
| Div
| BinExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = '/'
|
| ----------------------------------------------------------------------
| Methods inherited from BinExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class EnvironmentAttribute(Expr)
| EnvironmentAttribute(*fields: Any, **attributes: Any) -> None
|
| Loads an attribute from the environment object. This is useful for
| extensions that want to call a callback stored on the environment.
|
| Method resolution order:
| EnvironmentAttribute
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'name': <class 'str'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('name',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class EvalContext(builtins.object)
| EvalContext(environment: 'Environment', template_name: Optional[str] = None) -> None
|
| Holds evaluation time information. Custom attributes can be attached
| to it in extensions.
|
| Methods defined here:
|
| __init__(self, environment: 'Environment', template_name: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| revert(self, old: Mapping[str, Any]) -> None
|
| save(self) -> Mapping[str, Any]
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class EvalContextModifier(Stmt)
| EvalContextModifier(*fields: Any, **attributes: Any) -> None
|
| Modifies the eval context. For each option that should be modified,
| a :class:`Keyword` has to be added to the :attr:`options` list.
|
| Example to change the `autoescape` setting::
|
| EvalContextModifier(options=[Keyword('autoescape', Const(True))])
|
| Method resolution order:
| EvalContextModifier
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'options': typing.List[jinja2.nodes.Keyword]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('options',)
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Expr(Node)
| Expr(*fields: Any, **attributes: Any) -> None
|
| Baseclass for all expressions.
|
| Method resolution order:
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = True
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ExprStmt(Stmt)
| ExprStmt(*fields: Any, **attributes: Any) -> None
|
| A statement that evaluates an expression and discards the result.
|
| Method resolution order:
| ExprStmt
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'node': <class 'jinja2.nodes.Node'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node',)
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Extends(Stmt)
| Extends(*fields: Any, **attributes: Any) -> None
|
| Represents an extends statement.
|
| Method resolution order:
| Extends
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'template': 'Expr'}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('template',)
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ExtensionAttribute(Expr)
| ExtensionAttribute(*fields: Any, **attributes: Any) -> None
|
| Returns the attribute of an extension bound to the environment.
| The identifier is the identifier of the :class:`Extension`.
|
| This node is usually constructed by calling the
| :meth:`~jinja2.ext.Extension.attr` method on an extension.
|
| Method resolution order:
| ExtensionAttribute
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'identifier': <class 'str'>, 'name': <class 'str'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('identifier', 'name')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Filter(_FilterTestCommon)
| Filter(*fields: Any, **attributes: Any) -> None
|
| Apply a filter to an expression. ``name`` is the name of the
| filter, the other fields are the same as :class:`Call`.
|
| If ``node`` is ``None``, the filter is being used in a filter block
| and is applied to the content of the block.
|
| Method resolution order:
| Filter
| _FilterTestCommon
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'node': typing.Optional[jinja2.nodes.Expr]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node', 'name', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class FilterBlock(Stmt)
| FilterBlock(*fields: Any, **attributes: Any) -> None
|
| Node for filter sections.
|
| Method resolution order:
| FilterBlock
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node], 'filter': '...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('body', 'filter')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class FloorDiv(BinExpr)
| FloorDiv(*fields: Any, **attributes: Any) -> None
|
| Divides the left by the right node and converts the
| result into an integer by truncating.
|
| Method resolution order:
| FloorDiv
| BinExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = '//'
|
| ----------------------------------------------------------------------
| Methods inherited from BinExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class For(Stmt)
| For(*fields: Any, **attributes: Any) -> None
|
| The for loop. `target` is the target for the iteration (usually a
| :class:`Name` or :class:`Tuple`), `iter` the iterable. `body` is a list
| of nodes that are used as loop-body, and `else_` a list of nodes for the
| `else` block. If no else node exists it has to be an empty list.
|
| For filtered nodes an expression can be stored as `test`, otherwise `None`.
|
| Method resolution order:
| For
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node], 'else_': ty...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('target', 'iter', 'body', 'else_', 'test', 'recursive')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class FromImport(Stmt)
| FromImport(*fields: Any, **attributes: Any) -> None
|
| A node that represents the from import tag. It's important to not
| pass unsafe names to the name attribute. The compiler translates the
| attribute lookups directly into getattr calls and does *not* use the
| subscript callback of the interface. As exported variables may not
| start with double underscores (which the parser asserts) this is not a
| problem for regular Jinja code, but if this node is used in an extension
| extra care must be taken.
|
| The list of names may contain tuples if aliases are wanted.
|
| Method resolution order:
| FromImport
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'names': typing.List[typing.Union[str, typing.Tuple...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('template', 'names', 'with_context')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Getattr(Expr)
| Getattr(*fields: Any, **attributes: Any) -> None
|
| Get an attribute or item from an expression that is a ascii-only
| bytestring and prefer the attribute.
|
| Method resolution order:
| Getattr
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'attr': <class 'str'>, 'ctx': <class 'str'>, 'node'...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node', 'attr', 'ctx')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Getitem(Expr)
| Getitem(*fields: Any, **attributes: Any) -> None
|
| Get an attribute or item from an expression and prefer the item.
|
| Method resolution order:
| Getitem
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'arg': <class 'jinja2.nodes.Expr'>, 'ctx': <class '...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node', 'arg', 'ctx')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Helper(Node)
| Helper(*fields: Any, **attributes: Any) -> None
|
| Nodes that exist in a specific context only.
|
| Method resolution order:
| Helper
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = True
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class If(Stmt)
| If(*fields: Any, **attributes: Any) -> None
|
| If `test` is true, `body` is rendered, else `else_`.
|
| Method resolution order:
| If
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node], 'elif_': ty...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('test', 'body', 'elif_', 'else_')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Import(Stmt)
| Import(*fields: Any, **attributes: Any) -> None
|
| A node that represents the import tag.
|
| Method resolution order:
| Import
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'target': <class 'str'>, 'template': 'Expr', 'with_...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('template', 'target', 'with_context')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ImportedName(Expr)
| ImportedName(*fields: Any, **attributes: Any) -> None
|
| If created with an import name the import name is returned on node
| access. For example ``ImportedName('cgi.escape')`` returns the `escape`
| function from the cgi module on evaluation. Imports are optimized by the
| compiler so there is no need to assign them to local variables.
|
| Method resolution order:
| ImportedName
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'importname': <class 'str'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('importname',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Impossible(builtins.Exception)
| Raised if the node could not perform a requested action.
|
| Method resolution order:
| Impossible
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class Include(Stmt)
| Include(*fields: Any, **attributes: Any) -> None
|
| A node that represents the include tag.
|
| Method resolution order:
| Include
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'ignore_missing': <class 'bool'>, 'template': 'Expr...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('template', 'with_context', 'ignore_missing')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class InternalName(Expr)
| InternalName() -> None
|
| An internal name in the compiler. You cannot create these nodes
| yourself but the parser provides a
| :meth:`~jinja2.parser.Parser.free_identifier` method that creates
| a new identifier for you. This identifier is not available from the
| template and is not treated specially by the compiler.
|
| Method resolution order:
| InternalName
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| __init__(self) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'name': <class 'str'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('name',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Keyword(Helper)
| Keyword(*fields: Any, **attributes: Any) -> None
|
| A key, value pair for keyword arguments where key is a string.
|
| Method resolution order:
| Keyword
| Helper
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Tuple[str, Any]
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'key': <class 'str'>, 'value': <class 'jinja2.nodes...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('key', 'value')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class List(Literal)
| List(*fields: Any, **attributes: Any) -> None
|
| Any list literal such as ``[1, 2, 3]``
|
| Method resolution order:
| List
| Literal
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> List[Any]
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'items': typing.List[jinja2.nodes.Expr]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('items',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Literal(Expr)
| Literal(*fields: Any, **attributes: Any) -> None
|
| Baseclass for literals.
|
| Method resolution order:
| Literal
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = True
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Macro(Stmt)
| Macro(*fields: Any, **attributes: Any) -> None
|
| A macro definition. `name` is the name of the macro, `args` a list of
| arguments and `defaults` a list of defaults if there are any. `body` is
| a list of nodes for the macro body.
|
| Method resolution order:
| Macro
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'args': typing.List[ForwardRef('Name')], 'body': ty...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('name', 'args', 'defaults', 'body')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class MarkSafe(Expr)
| MarkSafe(*fields: Any, **attributes: Any) -> None
|
| Mark the wrapped expression as safe (wrap it as `Markup`).
|
| Method resolution order:
| MarkSafe
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> markupsafe.Markup
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'expr': <class 'jinja2.nodes.Expr'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('expr',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class MarkSafeIfAutoescape(Expr)
| MarkSafeIfAutoescape(*fields: Any, **attributes: Any) -> None
|
| Mark the wrapped expression as safe (wrap it as `Markup`) but
| only if autoescaping is active.
|
| .. versionadded:: 2.5
|
| Method resolution order:
| MarkSafeIfAutoescape
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Union[markupsafe.Markup, Any]
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'expr': <class 'jinja2.nodes.Expr'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('expr',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Mod(BinExpr)
| Mod(*fields: Any, **attributes: Any) -> None
|
| Left modulo right.
|
| Method resolution order:
| Mod
| BinExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = '%'
|
| ----------------------------------------------------------------------
| Methods inherited from BinExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Mul(BinExpr)
| Mul(*fields: Any, **attributes: Any) -> None
|
| Multiplies the left with the right node.
|
| Method resolution order:
| Mul
| BinExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = '*'
|
| ----------------------------------------------------------------------
| Methods inherited from BinExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class NSRef(Expr)
| NSRef(*fields: Any, **attributes: Any) -> None
|
| Reference to a namespace value assignment
|
| Method resolution order:
| NSRef
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'attr': <class 'str'>, 'name': <class 'str'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('name', 'attr')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Name(Expr)
| Name(*fields: Any, **attributes: Any) -> None
|
| Looks up a name or stores a value in a name.
| The `ctx` of the node can be one of the following values:
|
| - `store`: store a value in the name
| - `load`: load that name
| - `param`: like `store` but if the name was defined as function parameter.
|
| Method resolution order:
| Name
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'ctx': <class 'str'>, 'name': <class 'str'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('name', 'ctx')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Neg(UnaryExpr)
| Neg(*fields: Any, **attributes: Any) -> None
|
| Make the expression negative.
|
| Method resolution order:
| Neg
| UnaryExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node',)
|
| operator = '-'
|
| ----------------------------------------------------------------------
| Methods inherited from UnaryExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Node(builtins.object)
| Node(*fields: Any, **attributes: Any) -> None
|
| Baseclass for all Jinja nodes. There are a number of nodes available
| of different types. There are four major types:
|
| - :class:`Stmt`: statements
| - :class:`Expr`: expressions
| - :class:`Helper`: helper nodes
| - :class:`Template`: the outermost wrapper node
|
| All nodes have fields and attributes. Fields may be other nodes, lists,
| or arbitrary values. Fields are passed to the constructor as regular
| positional arguments, attributes as keyword arguments. Each node has
| two attributes: `lineno` (the line number of the node) and `environment`.
| The `environment` attribute is set at the end of the parsing process for
| all nodes automatically.
|
| Methods defined here:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'attributes': typing.Tuple[str, ...], 'environment'...
|
| abstract = True
|
| attributes = ('lineno', 'environment')
|
| fields = ()
class NodeType(builtins.type)
| NodeType(*args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| A metaclass for nodes that handles the field and attribute
| inheritance. fields and attributes from the parent class are
| automatically forwarded to the child.
|
| Method resolution order:
| NodeType
| builtins.type
| builtins.object
|
| Static methods defined here:
|
| __new__ = _failing_new(*args: Any, **kwargs: Any) -> 'te.NoReturn'
| # make sure nobody creates custom nodes
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.type:
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __dir__(self, /)
| Specialized __dir__ implementation for types.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __instancecheck__(self, instance, /)
| Check if an object is an instance.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __ror__(self, value, /)
| Return value|self.
|
| __setattr__(self, name, value, /)
| Implement setattr(self, name, value).
|
| __sizeof__(self, /)
| Return memory consumption of the type object.
|
| __subclasscheck__(self, subclass, /)
| Check if a class is a subclass.
|
| __subclasses__(self, /)
| Return a list of immediate subclasses.
|
| mro(self, /)
| Return a type's method resolution order.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.type:
|
| __prepare__(...)
| __prepare__() -> dict
| used to create the namespace for the class statement
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.type:
|
| __abstractmethods__
|
| __dict__
|
| __text_signature__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.type:
|
| __base__ = <class 'type'>
| type(object) -> the object's type
| type(name, bases, dict, **kwds) -> a new type
|
|
| __bases__ = (<class 'type'>,)
|
| __basicsize__ = 920
|
| __dictoffset__ = 264
|
| __flags__ = 2156420608
|
| __itemsize__ = 40
|
| __mro__ = (<class 'jinja2.nodes.NodeType'>, <class 'type'>, <class 'ob...
|
| __type_params__ = ()
|
| __weakrefoffset__ = 368
class Not(UnaryExpr)
| Not(*fields: Any, **attributes: Any) -> None
|
| Negate the expression.
|
| Method resolution order:
| Not
| UnaryExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node',)
|
| operator = 'not'
|
| ----------------------------------------------------------------------
| Methods inherited from UnaryExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from UnaryExpr:
|
| __annotations__ = {'node': <class 'jinja2.nodes.Expr'>, 'operator': <c...
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Operand(Helper)
| Operand(*fields: Any, **attributes: Any) -> None
|
| Holds an operator and an expression.
|
| Method resolution order:
| Operand
| Helper
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'expr': <class 'jinja2.nodes.Expr'>, 'op': <class '...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('op', 'expr')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Or(BinExpr)
| Or(*fields: Any, **attributes: Any) -> None
|
| Short circuited OR.
|
| Method resolution order:
| Or
| BinExpr
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = 'or'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BinExpr:
|
| __annotations__ = {'left': <class 'jinja2.nodes.Expr'>, 'operator': <c...
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Output(Stmt)
| Output(*fields: Any, **attributes: Any) -> None
|
| A node that holds multiple expressions which are then printed out.
| This is used both for the `print` statement and the regular template data.
|
| Method resolution order:
| Output
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'nodes': typing.List[ForwardRef('Expr')]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('nodes',)
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class OverlayScope(Stmt)
| OverlayScope(*fields: Any, **attributes: Any) -> None
|
| An overlay scope for extensions. This is a largely unoptimized scope
| that however can be used to introduce completely arbitrary variables into
| a sub scope from a dictionary or dictionary like object. The `context`
| field has to evaluate to a dictionary object.
|
| Example usage::
|
| OverlayScope(context=self.call_method('get_context'),
| body=[...])
|
| .. versionadded:: 2.10
|
| Method resolution order:
| OverlayScope
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node], 'context': ...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('context', 'body')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Pair(Helper)
| Pair(*fields: Any, **attributes: Any) -> None
|
| A key, value pair for dicts.
|
| Method resolution order:
| Pair
| Helper
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Tuple[Any, Any]
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'key': <class 'jinja2.nodes.Expr'>, 'value': <class...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('key', 'value')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Pos(UnaryExpr)
| Pos(*fields: Any, **attributes: Any) -> None
|
| Make the expression positive (noop for most expressions)
|
| Method resolution order:
| Pos
| UnaryExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node',)
|
| operator = '+'
|
| ----------------------------------------------------------------------
| Methods inherited from UnaryExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from UnaryExpr:
|
| __annotations__ = {'node': <class 'jinja2.nodes.Expr'>, 'operator': <c...
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Pow(BinExpr)
| Pow(*fields: Any, **attributes: Any) -> None
|
| Left to the power of right.
|
| Method resolution order:
| Pow
| BinExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = '**'
|
| ----------------------------------------------------------------------
| Methods inherited from BinExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BinExpr:
|
| __annotations__ = {'left': <class 'jinja2.nodes.Expr'>, 'operator': <c...
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Scope(Stmt)
| Scope(*fields: Any, **attributes: Any) -> None
|
| An artificial scope.
|
| Method resolution order:
| Scope
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('body',)
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ScopedEvalContextModifier(EvalContextModifier)
| ScopedEvalContextModifier(*fields: Any, **attributes: Any) -> None
|
| Modifies the eval context and reverts it later. Works exactly like
| :class:`EvalContextModifier` but will only modify the
| :class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
|
| Method resolution order:
| ScopedEvalContextModifier
| EvalContextModifier
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('options', 'body')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Slice(Expr)
| Slice(*fields: Any, **attributes: Any) -> None
|
| Represents a slice object. This must only be used as argument for
| :class:`Subscript`.
|
| Method resolution order:
| Slice
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> slice
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'start': typing.Optional[jinja2.nodes.Expr], 'step'...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('start', 'stop', 'step')
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Stmt(Node)
| Stmt(*fields: Any, **attributes: Any) -> None
|
| Base node for all statements.
|
| Method resolution order:
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| abstract = True
|
| attributes = ('lineno', 'environment')
|
| fields = ()
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Sub(BinExpr)
| Sub(*fields: Any, **attributes: Any) -> None
|
| Subtract the right from the left node.
|
| Method resolution order:
| Sub
| BinExpr
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('left', 'right')
|
| operator = '-'
|
| ----------------------------------------------------------------------
| Methods inherited from BinExpr:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BinExpr:
|
| __annotations__ = {'left': <class 'jinja2.nodes.Expr'>, 'operator': <c...
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Template(Node)
| Template(*fields: Any, **attributes: Any) -> None
|
| Node that represents a template. This must be the outermost node that
| is passed to the compiler.
|
| Method resolution order:
| Template
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node]}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('body',)
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class TemplateData(Literal)
| TemplateData(*fields: Any, **attributes: Any) -> None
|
| A constant template string.
|
| Method resolution order:
| TemplateData
| Literal
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> str
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'data': <class 'str'>}
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('data',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Test(_FilterTestCommon)
| Test(*fields: Any, **attributes: Any) -> None
|
| Apply a test to an expression. ``name`` is the name of the test,
| the other field are the same as :class:`Call`.
|
| .. versionchanged:: 3.0
| ``as_const`` shares the same logic for filters and tests. Tests
| check for volatile, async, and ``@pass_context`` etc.
| decorators.
|
| Method resolution order:
| Test
| _FilterTestCommon
| Expr
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('node', 'name', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
|
| ----------------------------------------------------------------------
| Methods inherited from _FilterTestCommon:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from _FilterTestCommon:
|
| __annotations__ = {'args': typing.List[jinja2.nodes.Expr], 'dyn_args':...
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Tuple(Literal)
| Tuple(*fields: Any, **attributes: Any) -> None
|
| For loop unpacking and some other things like multiple arguments
| for subscripts. Like for :class:`Name` `ctx` specifies if the tuple
| is used for loading the names or storing.
|
| Method resolution order:
| Tuple
| Literal
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Tuple[Any, ...]
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'ctx': <class 'str'>, 'items': typing.List[jinja2.n...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('items', 'ctx')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class UnaryExpr(Expr)
| UnaryExpr(*fields: Any, **attributes: Any) -> None
|
| Baseclass for all unary expressions.
|
| Method resolution order:
| UnaryExpr
| Expr
| Node
| builtins.object
|
| Methods defined here:
|
| as_const(self, eval_ctx: Optional[jinja2.nodes.EvalContext] = None) -> Any
| Return the value of the expression as constant or raise
| :exc:`Impossible` if this was not possible.
|
| An :class:`EvalContext` can be provided, if none is given
| a default context is created which requires the nodes to have
| an attached environment.
|
| .. versionchanged:: 2.4
| the `eval_ctx` parameter was added.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'node': <class 'jinja2.nodes.Expr'>, 'operator': <c...
|
| abstract = True
|
| attributes = ('lineno', 'environment')
|
| fields = ('node',)
|
| ----------------------------------------------------------------------
| Methods inherited from Expr:
|
| can_assign(self) -> bool
| Check if it's possible to assign something to this node.
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class With(Stmt)
| With(*fields: Any, **attributes: Any) -> None
|
| Specific node for with statements. In older versions of Jinja the
| with statement was implemented on the base of the `Scope` node instead.
|
| .. versionadded:: 2.9.3
|
| Method resolution order:
| With
| Stmt
| Node
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {'body': typing.List[jinja2.nodes.Node], 'targets': ...
|
| abstract = False
|
| attributes = ('lineno', 'environment')
|
| fields = ('targets', 'values', 'body')
|
| ----------------------------------------------------------------------
| Methods inherited from Node:
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __init__(self, *fields: Any, **attributes: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| dump(self) -> str
|
| find(self, node_type: Type[~_NodeBound]) -> Optional[~_NodeBound]
| Find the first node of a given type. If no such node exists the
| return value is `None`.
|
| find_all(self, node_type: Union[Type[~_NodeBound], Tuple[Type[~_NodeBound], ...]]) -> Iterator[~_NodeBound]
| Find all the nodes of a given type. If the type is a tuple,
| the check is performed for any of the tuple items.
|
| iter_child_nodes(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[ForwardRef('Node')]
| Iterates over all direct child nodes of the node. This iterates
| over all fields and yields the values of they are nodes. If the value
| of a field is a list all the nodes in that list are returned.
|
| iter_fields(self, exclude: Optional[Container[str]] = None, only: Optional[Container[str]] = None) -> Iterator[Tuple[str, Any]]
| This method iterates over all fields that are defined and yields
| ``(key, value)`` tuples. Per default all fields are returned, but
| it's possible to limit that to some fields by providing the `only`
| parameter or to exclude some using the `exclude` parameter. Both
| should be sets or tuples of field names.
|
| set_ctx(self, ctx: str) -> 'Node'
| Reset the context of a node and all child nodes. Per default the
| parser will all generate nodes that have a 'load' context as it's the
| most common one. This method is used in the parser to set assignment
| targets and other nodes to a store context.
|
| set_environment(self, environment: 'Environment') -> 'Node'
| Set the environment for all nodes.
|
| set_lineno(self, lineno: int, override: bool = False) -> 'Node'
| Set the line numbers of the node and children.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Node:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
args_as_const(node: Union[ForwardRef('_FilterTestCommon'), ForwardRef('Call')], eval_ctx: Optional[jinja2.nodes.EvalContext]) -> Tuple[List[Any], Dict[Any, Any]]
get_eval_context(node: 'Node', ctx: Optional[jinja2.nodes.EvalContext]) -> jinja2.nodes.EvalContext
DATA
__annotations__ = {'_binop_to_func': typing.Dict[str, typing.Callable[...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\nodes.py
jinja2.optimizer
Python Library Documentation: module jinja2.optimizer in jinja2
NAME
jinja2.optimizer
DESCRIPTION
The optimizer tries to constant fold expressions and modify the AST
in place so that it should be faster to evaluate.
Because the AST does not contain all the scoping information and the
compiler has to find that out, we cannot do all the optimizations we
want. For example, loop unrolling doesn't work because unrolled loops
would have a different scope. The solution would be a second syntax tree
that stored the scoping rules.
CLASSES
jinja2.visitor.NodeTransformer(jinja2.visitor.NodeVisitor)
Optimizer
class Optimizer(jinja2.visitor.NodeTransformer)
| Optimizer(environment: 't.Optional[Environment]') -> None
|
| Method resolution order:
| Optimizer
| jinja2.visitor.NodeTransformer
| jinja2.visitor.NodeVisitor
| builtins.object
|
| Methods defined here:
|
| __init__(self, environment: 't.Optional[Environment]') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> jinja2.nodes.Node
| Called if no explicit visitor function exists for a node.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from jinja2.visitor.NodeTransformer:
|
| visit_list(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> List[jinja2.nodes.Node]
| As transformers may return lists in some places this method
| can be used to enforce a list as return value.
|
| ----------------------------------------------------------------------
| Methods inherited from jinja2.visitor.NodeVisitor:
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from jinja2.visitor.NodeVisitor:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
optimize(node: jinja2.nodes.Node, environment: 'Environment') -> jinja2.nodes.Node
The context hint can be used to perform an static optimization
based on the context given.
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\optimizer.py
jinja2.parser
Python Library Documentation: module jinja2.parser in jinja2
NAME
jinja2.parser - Parse tokens from the lexer into nodes for the compiler.
CLASSES
builtins.object
Parser
class Parser(builtins.object)
| Parser(environment: 'Environment', source: str, name: Optional[str] = None, filename: Optional[str] = None, state: Optional[str] = None) -> None
|
| This is the central parsing class Jinja uses. It's passed to
| extensions and can be used to parse expressions or statements.
|
| Methods defined here:
|
| __init__(self, environment: 'Environment', source: str, name: Optional[str] = None, filename: Optional[str] = None, state: Optional[str] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| fail(self, msg: str, lineno: Optional[int] = None, exc: Type[jinja2.exceptions.TemplateSyntaxError] = <class 'jinja2.exceptions.TemplateSyntaxError'>) -> 'te.NoReturn'
| Convenience method that raises `exc` with the message, passed
| line number or last line number as well as the current name and
| filename.
|
| fail_eof(self, end_tokens: Optional[Tuple[str, ...]] = None, lineno: Optional[int] = None) -> 'te.NoReturn'
| Like fail_unknown_tag but for end of template situations.
|
| fail_unknown_tag(self, name: str, lineno: Optional[int] = None) -> 'te.NoReturn'
| Called if the parser encounters an unknown tag. Tries to fail
| with a human readable error message that could help to identify
| the problem.
|
| free_identifier(self, lineno: Optional[int] = None) -> jinja2.nodes.InternalName
| Return a new free identifier as :class:`~jinja2.nodes.InternalName`.
|
| is_tuple_end(self, extra_end_rules: Optional[Tuple[str, ...]] = None) -> bool
| Are we at the end of a tuple?
|
| parse(self) -> jinja2.nodes.Template
| Parse the whole template into a `Template` node.
|
| parse_and(self) -> jinja2.nodes.Expr
|
| parse_assign_target(self, with_tuple: bool = True, name_only: bool = False, extra_end_rules: Optional[Tuple[str, ...]] = None, with_namespace: bool = False) -> Union[jinja2.nodes.NSRef, jinja2.nodes.Name, jinja2.nodes.Tuple]
| Parse an assignment target. As Jinja allows assignments to
| tuples, this function can parse all allowed assignment targets. Per
| default assignments to tuples are parsed, that can be disable however
| by setting `with_tuple` to `False`. If only assignments to names are
| wanted `name_only` can be set to `True`. The `extra_end_rules`
| parameter is forwarded to the tuple parsing function. If
| `with_namespace` is enabled, a namespace assignment may be parsed.
|
| parse_autoescape(self) -> jinja2.nodes.Scope
|
| parse_block(self) -> jinja2.nodes.Block
|
| parse_call(self, node: jinja2.nodes.Expr) -> jinja2.nodes.Call
|
| parse_call_args(self) -> Tuple[List[jinja2.nodes.Expr], List[jinja2.nodes.Keyword], Optional[jinja2.nodes.Expr], Optional[jinja2.nodes.Expr]]
|
| parse_call_block(self) -> jinja2.nodes.CallBlock
|
| parse_compare(self) -> jinja2.nodes.Expr
|
| parse_concat(self) -> jinja2.nodes.Expr
|
| parse_condexpr(self) -> jinja2.nodes.Expr
|
| parse_dict(self) -> jinja2.nodes.Dict
|
| parse_expression(self, with_condexpr: bool = True) -> jinja2.nodes.Expr
| Parse an expression. Per default all expressions are parsed, if
| the optional `with_condexpr` parameter is set to `False` conditional
| expressions are not parsed.
|
| parse_extends(self) -> jinja2.nodes.Extends
|
| parse_filter(self, node: Optional[jinja2.nodes.Expr], start_inline: bool = False) -> Optional[jinja2.nodes.Expr]
|
| parse_filter_block(self) -> jinja2.nodes.FilterBlock
|
| parse_filter_expr(self, node: jinja2.nodes.Expr) -> jinja2.nodes.Expr
|
| parse_for(self) -> jinja2.nodes.For
| Parse a for loop.
|
| parse_from(self) -> jinja2.nodes.FromImport
|
| parse_if(self) -> jinja2.nodes.If
| Parse an if construct.
|
| parse_import(self) -> jinja2.nodes.Import
|
| parse_import_context(self, node: ~_ImportInclude, default: bool) -> ~_ImportInclude
|
| parse_include(self) -> jinja2.nodes.Include
|
| parse_list(self) -> jinja2.nodes.List
|
| parse_macro(self) -> jinja2.nodes.Macro
|
| parse_math1(self) -> jinja2.nodes.Expr
|
| parse_math2(self) -> jinja2.nodes.Expr
|
| parse_not(self) -> jinja2.nodes.Expr
|
| parse_or(self) -> jinja2.nodes.Expr
|
| parse_postfix(self, node: jinja2.nodes.Expr) -> jinja2.nodes.Expr
|
| parse_pow(self) -> jinja2.nodes.Expr
|
| parse_primary(self) -> jinja2.nodes.Expr
|
| parse_print(self) -> jinja2.nodes.Output
|
| parse_set(self) -> Union[jinja2.nodes.Assign, jinja2.nodes.AssignBlock]
| Parse an assign statement.
|
| parse_signature(self, node: ~_MacroCall) -> None
|
| parse_statement(self) -> Union[jinja2.nodes.Node, List[jinja2.nodes.Node]]
| Parse a single statement.
|
| parse_statements(self, end_tokens: Tuple[str, ...], drop_needle: bool = False) -> List[jinja2.nodes.Node]
| Parse multiple statements into a list until one of the end tokens
| is reached. This is used to parse the body of statements as it also
| parses template data if appropriate. The parser checks first if the
| current token is a colon and skips it if there is one. Then it checks
| for the block end and parses until if one of the `end_tokens` is
| reached. Per default the active token in the stream at the end of
| the call is the matched end token. If this is not wanted `drop_needle`
| can be set to `True` and the end token is removed.
|
| parse_subscribed(self) -> jinja2.nodes.Expr
|
| parse_subscript(self, node: jinja2.nodes.Expr) -> Union[jinja2.nodes.Getattr, jinja2.nodes.Getitem]
|
| parse_test(self, node: jinja2.nodes.Expr) -> jinja2.nodes.Expr
|
| parse_tuple(self, simplified: bool = False, with_condexpr: bool = True, extra_end_rules: Optional[Tuple[str, ...]] = None, explicit_parentheses: bool = False) -> Union[jinja2.nodes.Tuple, jinja2.nodes.Expr]
| Works like `parse_expression` but if multiple expressions are
| delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
| This method could also return a regular expression instead of a tuple
| if no commas where found.
|
| The default parsing mode is a full tuple. If `simplified` is `True`
| only names and literals are parsed. The `no_condexpr` parameter is
| forwarded to :meth:`parse_expression`.
|
| Because tuples do not require delimiters and may end in a bogus comma
| an extra hint is needed that marks the end of a tuple. For example
| for loops support tuples between `for` and `in`. In that case the
| `extra_end_rules` is set to ``['name:in']``.
|
| `explicit_parentheses` is true if the parsing was triggered by an
| expression in parentheses. This is used to figure out if an empty
| tuple is a valid expression or not.
|
| parse_unary(self, with_filter: bool = True) -> jinja2.nodes.Expr
|
| parse_with(self) -> jinja2.nodes.With
|
| subparse(self, end_tokens: Optional[Tuple[str, ...]] = None) -> List[jinja2.nodes.Node]
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
DATA
__annotations__ = {'_math_nodes': typing.Dict[str, typing.Type[jinja2....
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\parser.py
jinja2.pass_context
Python Library Documentation: function pass_context in module jinja2.utils
pass_context(f: ~F) -> ~F
Pass the :class:`~jinja2.runtime.Context` as the first argument
to the decorated function when called while rendering a template.
Can be used on functions, filters, and tests.
If only ``Context.eval_context`` is needed, use
:func:`pass_eval_context`. If only ``Context.environment`` is
needed, use :func:`pass_environment`.
.. versionadded:: 3.0.0
Replaces ``contextfunction`` and ``contextfilter``.
jinja2.pass_environment
Python Library Documentation: function pass_environment in module jinja2.utils
pass_environment(f: ~F) -> ~F
Pass the :class:`~jinja2.Environment` as the first argument to
the decorated function when called while rendering a template.
Can be used on functions, filters, and tests.
.. versionadded:: 3.0.0
Replaces ``environmentfunction`` and ``environmentfilter``.
jinja2.pass_eval_context
Python Library Documentation: function pass_eval_context in module jinja2.utils
pass_eval_context(f: ~F) -> ~F
Pass the :class:`~jinja2.nodes.EvalContext` as the first argument
to the decorated function when called while rendering a template.
See :ref:`eval-context`.
Can be used on functions, filters, and tests.
If only ``EvalContext.environment`` is needed, use
:func:`pass_environment`.
.. versionadded:: 3.0.0
Replaces ``evalcontextfunction`` and ``evalcontextfilter``.
jinja2.runtime
Python Library Documentation: module jinja2.runtime in jinja2
NAME
jinja2.runtime - The runtime functions and state used by compiled templates.
CLASSES
builtins.object
BlockReference
Context
LoopContext
AsyncLoopContext
Macro
TemplateReference
Undefined
ChainableUndefined
DebugUndefined
StrictUndefined
class AsyncLoopContext(LoopContext)
| AsyncLoopContext(iterable: Iterable[~V], undefined: Type[ForwardRef('Undefined')], recurse: Optional[ForwardRef('LoopRenderFunc')] = None, depth0: int = 0) -> None
|
| Method resolution order:
| AsyncLoopContext
| LoopContext
| builtins.object
|
| Methods defined here:
|
| __aiter__(self) -> 'AsyncLoopContext'
|
| async __anext__(self) -> Tuple[Any, ForwardRef('AsyncLoopContext')]
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| last
| Whether this is the last iteration of the loop.
|
| Causes the iterable to advance early. See
| :func:`itertools.groupby` for issues this can cause.
| The :func:`groupby` filter avoids that issue.
|
| length
| Length of the iterable.
|
| If the iterable is a generator or otherwise does not have a
| size, it is eagerly evaluated to get a size.
|
| nextitem
| The item in the next iteration. Undefined during the last
| iteration.
|
| Causes the iterable to advance early. See
| :func:`itertools.groupby` for issues this can cause.
| The :func:`jinja-filters.groupby` filter avoids that issue.
|
| revindex
| Number of iterations from the end of the loop, ending at 1.
|
| Requires calculating :attr:`length`.
|
| revindex0
| Number of iterations from the end of the loop, ending at 0.
|
| Requires calculating :attr:`length`.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_iterator': typing.AsyncIterator[typing.Any]}
|
| ----------------------------------------------------------------------
| Methods inherited from LoopContext:
|
| __call__(self, iterable: Iterable[~V]) -> str
| When iterating over nested data, render the body of the loop
| recursively with the given inner iterable data.
|
| The loop must have the ``recursive`` marker for this to work.
|
| __init__(self, iterable: Iterable[~V], undefined: Type[ForwardRef('Undefined')], recurse: Optional[ForwardRef('LoopRenderFunc')] = None, depth0: int = 0) -> None
| :param iterable: Iterable to wrap.
| :param undefined: :class:`Undefined` class to use for next and
| previous items.
| :param recurse: The function to render the loop body when the
| loop is marked recursive.
| :param depth0: Incremented when looping recursively.
|
| __iter__(self) -> 'LoopContext'
|
| __len__(self) -> int
|
| __next__(self) -> Tuple[Any, ForwardRef('LoopContext')]
|
| __repr__(self) -> str
| Return repr(self).
|
| changed(self, *value: Any) -> bool
| Return ``True`` if previously called with a different value
| (including when called for the first time).
|
| :param value: One or more values to compare to the last call.
|
| cycle(self, *args: ~V) -> ~V
| Return a value from the given args, cycling through based on
| the current :attr:`index0`.
|
| :param args: One or more values to cycle through.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from LoopContext:
|
| depth
| How many levels deep a recursive loop currently is, starting at 1.
|
| first
| Whether this is the first iteration of the loop.
|
| index
| Current iteration of the loop, starting at 1.
|
| previtem
| The item in the previous iteration. Undefined during the
| first iteration.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from LoopContext:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from LoopContext:
|
| index0 = -1
class BlockReference(builtins.object)
| BlockReference(name: str, context: 'Context', stack: List[Callable[[ForwardRef('Context')], Iterator[str]]], depth: int) -> None
|
| One block on a template reference.
|
| Methods defined here:
|
| __call__(self) -> str
| Call self as a function.
|
| __init__(self, name: str, context: 'Context', stack: List[Callable[[ForwardRef('Context')], Iterator[str]]], depth: int) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| super
| Super the block.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ChainableUndefined(Undefined)
| ChainableUndefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
|
| An undefined that is chainable, where both ``__getattr__`` and
| ``__getitem__`` return itself rather than raising an
| :exc:`UndefinedError`.
|
| >>> foo = ChainableUndefined(name='foo')
| >>> str(foo.bar['baz'])
| ''
| >>> foo.bar['baz'] + 42
| Traceback (most recent call last):
| ...
| jinja2.exceptions.UndefinedError: 'foo' is undefined
|
| .. versionadded:: 2.11.0
|
| Method resolution order:
| ChainableUndefined
| Undefined
| builtins.object
|
| Methods defined here:
|
| __getattr__(self, _: str) -> 'ChainableUndefined'
|
| __getitem__ = __getattr__(self, _: str) -> 'ChainableUndefined'
|
| __html__(self) -> str
|
| ----------------------------------------------------------------------
| Methods inherited from Undefined:
|
| __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| async __aiter__(self) -> AsyncIterator[Any]
|
| __bool__(self) -> bool
|
| __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __hash__(self) -> int
| Return hash(self).
|
| __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __iter__(self) -> Iterator[Any]
|
| __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __len__(self) -> int
|
| __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ne__(self, other: Any) -> bool
| Return self!=value.
|
| __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __repr__(self) -> str
| Return repr(self).
|
| __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __str__(self) -> str
| Return str(self).
|
| __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
class Context(builtins.object)
| Context(environment: 'Environment', parent: Dict[str, Any], name: Optional[str], blocks: Dict[str, Callable[[ForwardRef('Context')], Iterator[str]]], globals: Optional[MutableMapping[str, Any]] = None)
|
| The template context holds the variables of a template. It stores the
| values passed to the template and also the names the template exports.
| Creating instances is neither supported nor useful as it's created
| automatically at various stages of the template evaluation and should not
| be created by hand.
|
| The context is immutable. Modifications on :attr:`parent` **must not**
| happen and modifications on :attr:`vars` are allowed from generated
| template code only. Template filters and global functions marked as
| :func:`pass_context` get the active context passed as first argument
| and are allowed to access the context read-only.
|
| The template context supports read only dict operations (`get`,
| `keys`, `values`, `items`, `iterkeys`, `itervalues`, `iteritems`,
| `__getitem__`, `__contains__`). Additionally there is a :meth:`resolve`
| method that doesn't fail with a `KeyError` but returns an
| :class:`Undefined` object for missing variables.
|
| Methods defined here:
|
| __contains__(self, name: str) -> bool
|
| __getitem__(self, key: str) -> Any
| Look up a variable by name with ``[]`` syntax, or raise a
| ``KeyError`` if the key is not found.
|
| __init__(self, environment: 'Environment', parent: Dict[str, Any], name: Optional[str], blocks: Dict[str, Callable[[ForwardRef('Context')], Iterator[str]]], globals: Optional[MutableMapping[str, Any]] = None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| call(_Context__self, _Context__obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Union[Any, ForwardRef('Undefined')]
| Call the callable with the arguments and keyword arguments
| provided but inject the active context or environment as first
| argument if the callable has :func:`pass_context` or
| :func:`pass_environment`.
|
| derived(self, locals: Optional[Dict[str, Any]] = None) -> 'Context'
| Internal helper function to create a derived context. This is
| used in situations where the system needs a new context in the same
| template that is independent.
|
| get(self, key: str, default: Any = None) -> Any
| Look up a variable by name, or return a default if the key is
| not found.
|
| :param key: The variable name to look up.
| :param default: The value to return if the key is not found.
|
| get_all(self) -> Dict[str, Any]
| Return the complete context as dict including the exported
| variables. For optimizations reasons this might not return an
| actual copy so be careful with using it.
|
| get_exported(self) -> Dict[str, Any]
| Get a new dict with the exported variables.
|
| items(...) from dict
| D.items() -> a set-like object providing a view on D's items
|
| keys(...) from dict
| D.keys() -> a set-like object providing a view on D's keys
|
| resolve(self, key: str) -> Union[Any, ForwardRef('Undefined')]
| Look up a variable by name, or return an :class:`Undefined`
| object if the key is not found.
|
| If you need to add custom behavior, override
| :meth:`resolve_or_missing`, not this method. The various lookup
| functions use that method, not this one.
|
| :param key: The variable name to look up.
|
| resolve_or_missing(self, key: str) -> Any
| Look up a variable by name, or return a ``missing`` sentinel
| if the key is not found.
|
| Override this method to add custom lookup behavior.
| :meth:`resolve`, :meth:`get`, and :meth:`__getitem__` use this
| method. Don't call this method directly.
|
| :param key: The variable name to look up.
|
| super(self, name: str, current: Callable[[ForwardRef('Context')], Iterator[str]]) -> Union[ForwardRef('BlockReference'), ForwardRef('Undefined')]
| Render a parent block.
|
| values(...) from dict
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class DebugUndefined(Undefined)
| DebugUndefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
|
| An undefined that returns the debug info when printed.
|
| >>> foo = DebugUndefined(name='foo')
| >>> str(foo)
| '{{ foo }}'
| >>> not foo
| True
| >>> foo + 42
| Traceback (most recent call last):
| ...
| jinja2.exceptions.UndefinedError: 'foo' is undefined
|
| Method resolution order:
| DebugUndefined
| Undefined
| builtins.object
|
| Methods defined here:
|
| __str__(self) -> str
| Return str(self).
|
| ----------------------------------------------------------------------
| Methods inherited from Undefined:
|
| __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| async __aiter__(self) -> AsyncIterator[Any]
|
| __bool__(self) -> bool
|
| __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __getattr__(self, name: str) -> Any
|
| __getitem__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __hash__(self) -> int
| Return hash(self).
|
| __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __iter__(self) -> Iterator[Any]
|
| __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __len__(self) -> int
|
| __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ne__(self, other: Any) -> bool
| Return self!=value.
|
| __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __repr__(self) -> str
| Return repr(self).
|
| __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
class LoopContext(builtins.object)
| LoopContext(iterable: Iterable[~V], undefined: Type[ForwardRef('Undefined')], recurse: Optional[ForwardRef('LoopRenderFunc')] = None, depth0: int = 0) -> None
|
| A wrapper iterable for dynamic ``for`` loops, with information
| about the loop and iteration.
|
| Methods defined here:
|
| __call__(self, iterable: Iterable[~V]) -> str
| When iterating over nested data, render the body of the loop
| recursively with the given inner iterable data.
|
| The loop must have the ``recursive`` marker for this to work.
|
| __init__(self, iterable: Iterable[~V], undefined: Type[ForwardRef('Undefined')], recurse: Optional[ForwardRef('LoopRenderFunc')] = None, depth0: int = 0) -> None
| :param iterable: Iterable to wrap.
| :param undefined: :class:`Undefined` class to use for next and
| previous items.
| :param recurse: The function to render the loop body when the
| loop is marked recursive.
| :param depth0: Incremented when looping recursively.
|
| __iter__(self) -> 'LoopContext'
|
| __len__(self) -> int
|
| __next__(self) -> Tuple[Any, ForwardRef('LoopContext')]
|
| __repr__(self) -> str
| Return repr(self).
|
| changed(self, *value: Any) -> bool
| Return ``True`` if previously called with a different value
| (including when called for the first time).
|
| :param value: One or more values to compare to the last call.
|
| cycle(self, *args: ~V) -> ~V
| Return a value from the given args, cycling through based on
| the current :attr:`index0`.
|
| :param args: One or more values to cycle through.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| depth
| How many levels deep a recursive loop currently is, starting at 1.
|
| first
| Whether this is the first iteration of the loop.
|
| index
| Current iteration of the loop, starting at 1.
|
| last
| Whether this is the last iteration of the loop.
|
| Causes the iterable to advance early. See
| :func:`itertools.groupby` for issues this can cause.
| The :func:`groupby` filter avoids that issue.
|
| length
| Length of the iterable.
|
| If the iterable is a generator or otherwise does not have a
| size, it is eagerly evaluated to get a size.
|
| nextitem
| The item in the next iteration. Undefined during the last
| iteration.
|
| Causes the iterable to advance early. See
| :func:`itertools.groupby` for issues this can cause.
| The :func:`jinja-filters.groupby` filter avoids that issue.
|
| previtem
| The item in the previous iteration. Undefined during the
| first iteration.
|
| revindex
| Number of iterations from the end of the loop, ending at 1.
|
| Requires calculating :attr:`length`.
|
| revindex0
| Number of iterations from the end of the loop, ending at 0.
|
| Requires calculating :attr:`length`.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_after': typing.Any, '_before': typing.Any, '_curr...
|
| index0 = -1
class Macro(builtins.object)
| Macro(environment: 'Environment', func: Callable[..., str], name: str, arguments: List[str], catch_kwargs: bool, catch_varargs: bool, caller: bool, default_autoescape: Optional[bool] = None)
|
| Wraps a macro function.
|
| Methods defined here:
|
| __call__(self, *args: Any, **kwargs: Any) -> str
| Call self as a function.
|
| __init__(self, environment: 'Environment', func: Callable[..., str], name: str, arguments: List[str], catch_kwargs: bool, catch_varargs: bool, caller: bool, default_autoescape: Optional[bool] = None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class StrictUndefined(Undefined)
| StrictUndefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
|
| An undefined that barks on print and iteration as well as boolean
| tests and all kinds of comparisons. In other words: you can do nothing
| with it except checking if it's defined using the `defined` test.
|
| >>> foo = StrictUndefined(name='foo')
| >>> str(foo)
| Traceback (most recent call last):
| ...
| jinja2.exceptions.UndefinedError: 'foo' is undefined
| >>> not foo
| Traceback (most recent call last):
| ...
| jinja2.exceptions.UndefinedError: 'foo' is undefined
| >>> foo + 42
| Traceback (most recent call last):
| ...
| jinja2.exceptions.UndefinedError: 'foo' is undefined
|
| Method resolution order:
| StrictUndefined
| Undefined
| builtins.object
|
| Methods defined here:
|
| __bool__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __contains__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __eq__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __hash__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __iter__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __len__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ne__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __str__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| ----------------------------------------------------------------------
| Methods inherited from Undefined:
|
| __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| async __aiter__(self) -> AsyncIterator[Any]
|
| __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __getattr__(self, name: str) -> Any
|
| __getitem__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __repr__(self) -> str
| Return repr(self).
|
| __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
class TemplateReference(builtins.object)
| TemplateReference(context: 'Context') -> None
|
| The `self` in templates.
|
| Methods defined here:
|
| __getitem__(self, name: str) -> Any
|
| __init__(self, context: 'Context') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Undefined(builtins.object)
| Undefined(hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
|
| The default undefined type. This undefined type can be printed and
| iterated over, but every other access will raise an :exc:`UndefinedError`:
|
| >>> foo = Undefined(name='foo')
| >>> str(foo)
| ''
| >>> not foo
| True
| >>> foo + 42
| Traceback (most recent call last):
| ...
| jinja2.exceptions.UndefinedError: 'foo' is undefined
|
| Methods defined here:
|
| __add__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| async __aiter__(self) -> AsyncIterator[Any]
|
| __bool__(self) -> bool
|
| __call__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __complex__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __div__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __eq__(self, other: Any) -> bool
| Return self==value.
|
| __float__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __floordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ge__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __getattr__(self, name: str) -> Any
|
| __getitem__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __gt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __hash__(self) -> int
| Return hash(self).
|
| __init__(self, hint: Optional[str] = None, obj: Any = missing, name: Optional[str] = None, exc: Type[jinja2.exceptions.TemplateRuntimeError] = <class 'jinja2.exceptions.UndefinedError'>) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __int__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __iter__(self) -> Iterator[Any]
|
| __le__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __len__(self) -> int
|
| __lt__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __mul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __ne__(self, other: Any) -> bool
| Return self!=value.
|
| __neg__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pos__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __pow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __radd__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rdiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __repr__(self) -> str
| Return repr(self).
|
| __rfloordiv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmod__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rmul__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rpow__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rsub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __rtruediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __str__(self) -> str
| Return str(self).
|
| __sub__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
|
| __truediv__ = _fail_with_undefined_error(self, *args: Any, **kwargs: Any) -> 'te.NoReturn'
FUNCTIONS
concat = join(iterable, /) method of builtins.str instance
Concatenate any number of strings.
The string whose method is called is inserted in between each given string.
The result is returned as a new string.
Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
escape(...)
Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in the string with HTML-safe sequences. Use this if you need to display text that might contain such characters in HTML.
If the object has an ``__html__`` method, it is called and the return value is assumed to already be safe for HTML.
:param s: An object to be converted to a string and escaped.
:return: A :class:`Markup` string with the escaped text.
identity(x: ~V) -> ~V
Returns its argument. Useful for certain things in the
environment.
make_logging_undefined(logger: Optional[ForwardRef('logging.Logger')] = None, base: Type[jinja2.runtime.Undefined] = <class 'jinja2.runtime.Undefined'>) -> Type[jinja2.runtime.Undefined]
Given a logger object this returns a new undefined class that will
log certain failures. It will log iterations and printing. If no
logger is given a default logger is created.
Example::
logger = logging.getLogger(__name__)
LoggingUndefined = make_logging_undefined(
logger=logger,
base=Undefined
)
.. versionadded:: 2.8
:param logger: the logger to use. If not provided, a default logger
is created.
:param base: the base class to add logging functionality to. This
defaults to :class:`Undefined`.
markup_join(seq: Iterable[Any]) -> str
Concatenation that escapes if necessary and converts to string.
new_context(environment: 'Environment', template_name: Optional[str], blocks: Dict[str, Callable[[ForwardRef('Context')], Iterator[str]]], vars: Optional[Dict[str, Any]] = None, shared: bool = False, globals: Optional[MutableMapping[str, Any]] = None, locals: Optional[Mapping[str, Any]] = None) -> 'Context'
Internal helper for context creation.
soft_str(...)
Convert an object to a string if it isn't already. This preserves a :class:`Markup` string rather than converting it back to a basic string, so it will still be marked as safe and won't be escaped again.
>>> value = escape("<User 1>")
>>> value
Markup('<User 1>')
>>> escape(str(value))
Markup('&lt;User 1&gt;')
>>> escape(soft_str(value))
Markup('<User 1>')
str_join(seq: Iterable[Any]) -> str
Simple args to string conversion and concatenation.
DATA
F = ~F
V = ~V
async_exported = ['AsyncLoopContext', 'auto_aiter', 'auto_await']
exported = ['LoopContext', 'TemplateReference', 'Macro', 'Markup', 'Te...
missing = missing
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\runtime.py
jinja2.select_autoescape
Python Library Documentation: function select_autoescape in module jinja2.utils
select_autoescape(enabled_extensions: Collection[str] = ('html', 'htm', 'xml'), disabled_extensions: Collection[str] = (), default_for_string: bool = True, default: bool = False) -> Callable[[Optional[str]], bool]
Intelligently sets the initial value of autoescaping based on the
filename of the template. This is the recommended way to configure
autoescaping if you do not want to write a custom function yourself.
If you want to enable it for all templates created from strings or
for all templates with `.html` and `.xml` extensions::
from jinja2 import Environment, select_autoescape
env = Environment(autoescape=select_autoescape(
enabled_extensions=('html', 'xml'),
default_for_string=True,
))
Example configuration to turn it on at all times except if the template
ends with `.txt`::
from jinja2 import Environment, select_autoescape
env = Environment(autoescape=select_autoescape(
disabled_extensions=('txt',),
default_for_string=True,
default=True,
))
The `enabled_extensions` is an iterable of all the extensions that
autoescaping should be enabled for. Likewise `disabled_extensions` is
a list of all templates it should be disabled for. If a template is
loaded from a string then the default from `default_for_string` is used.
If nothing matches then the initial value of autoescaping is set to the
value of `default`.
For security reasons this function operates case insensitive.
.. versionadded:: 2.9
jinja2.tests
Python Library Documentation: module jinja2.tests in jinja2
NAME
jinja2.tests - Built-in template tests used with the ``is`` operator.
FUNCTIONS
test_boolean(value: Any) -> bool
Return true if the object is a boolean value.
.. versionadded:: 2.11
test_defined(value: Any) -> bool
Return true if the variable is defined:
.. sourcecode:: jinja
{% if variable is defined %}
value of variable: {{ variable }}
{% else %}
variable is not defined
{% endif %}
See the :func:`default` filter for a simple way to set undefined
variables.
test_divisibleby(value: int, num: int) -> bool
Check if a variable is divisible by a number.
test_escaped(value: Any) -> bool
Check if the value is escaped.
test_even(value: int) -> bool
Return true if the variable is even.
test_false(value: Any) -> bool
Return true if the object is False.
.. versionadded:: 2.11
test_filter(env: 'Environment', value: str) -> bool
Check if a filter exists by name. Useful if a filter may be
optionally available.
.. code-block:: jinja
{% if 'markdown' is filter %}
{{ value | markdown }}
{% else %}
{{ value }}
{% endif %}
.. versionadded:: 3.0
test_float(value: Any) -> bool
Return true if the object is a float.
.. versionadded:: 2.11
test_in(value: Any, seq: Container[Any]) -> bool
Check if value is in seq.
.. versionadded:: 2.10
test_integer(value: Any) -> bool
Return true if the object is an integer.
.. versionadded:: 2.11
test_iterable(value: Any) -> bool
Check if it's possible to iterate over an object.
test_lower(value: str) -> bool
Return true if the variable is lowercased.
test_mapping(value: Any) -> bool
Return true if the object is a mapping (dict etc.).
.. versionadded:: 2.6
test_none(value: Any) -> bool
Return true if the variable is none.
test_number(value: Any) -> bool
Return true if the variable is a number.
test_odd(value: int) -> bool
Return true if the variable is odd.
test_sameas(value: Any, other: Any) -> bool
Check if an object points to the same memory address than another
object:
.. sourcecode:: jinja
{% if foo.attribute is sameas false %}
the foo attribute really is the `False` singleton
{% endif %}
test_sequence(value: Any) -> bool
Return true if the variable is a sequence. Sequences are variables
that are iterable.
test_string(value: Any) -> bool
Return true if the object is a string.
test_test(env: 'Environment', value: str) -> bool
Check if a test exists by name. Useful if a test may be
optionally available.
.. code-block:: jinja
{% if 'loud' is test %}
{% if value is loud %}
{{ value|upper }}
{% else %}
{{ value|lower }}
{% endif %}
{% else %}
{{ value }}
{% endif %}
.. versionadded:: 3.0
test_true(value: Any) -> bool
Return true if the object is True.
.. versionadded:: 2.11
test_undefined(value: Any) -> bool
Like :func:`defined` but the other way round.
test_upper(value: str) -> bool
Return true if the variable is uppercased.
DATA
TESTS = {'!=': <built-in function ne>, '<': <built-in function lt>, '<...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\tests.py
jinja2.utils
Python Library Documentation: module jinja2.utils in jinja2
NAME
jinja2.utils
CLASSES
builtins.object
Cycler
Joiner
LRUCache
Namespace
class Cycler(builtins.object)
| Cycler(*items: Any) -> None
|
| Cycle through values by yield them one at a time, then restarting
| once the end is reached. Available as ``cycler`` in templates.
|
| Similar to ``loop.cycle``, but can be used outside loops or across
| multiple loops. For example, render a list of folders and files in a
| list, alternating giving them "odd" and "even" classes.
|
| .. code-block:: html+jinja
|
| {% set row_class = cycler("odd", "even") %}
| <ul class="browser">
| {% for folder in folders %}
| <li class="folder {{ row_class.next() }}">{{ folder }}
| {% endfor %}
| {% for file in files %}
| <li class="file {{ row_class.next() }}">{{ file }}
| {% endfor %}
| </ul>
|
| :param items: Each positional argument will be yielded in the order
| given for each cycle.
|
| .. versionadded:: 2.1
|
| Methods defined here:
|
| __init__(self, *items: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __next__ = next(self) -> Any
|
| next(self) -> Any
| Return the current item, then advance :attr:`current` to the
| next item.
|
| reset(self) -> None
| Resets the current item to the first item.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| current
| Return the current item. Equivalent to the item that will be
| returned next time :meth:`next` is called.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Joiner(builtins.object)
| Joiner(sep: str = ', ') -> None
|
| A joining helper for templates.
|
| Methods defined here:
|
| __call__(self) -> str
| Call self as a function.
|
| __init__(self, sep: str = ', ') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LRUCache(builtins.object)
| LRUCache(capacity: int) -> None
|
| A simple LRU Cache implementation.
|
| Methods defined here:
|
| __contains__(self, key: Any) -> bool
| Check if a key exists in this cache.
|
| __copy__ = copy(self) -> 'LRUCache'
|
| __delitem__(self, key: Any) -> None
| Remove an item from the cache dict.
| Raise a `KeyError` if it does not exist.
|
| __getitem__(self, key: Any) -> Any
| Get an item from the cache. Moves the item up so that it has the
| highest priority then.
|
| Raise a `KeyError` if it does not exist.
|
| __getnewargs__(self) -> Tuple[Any, ...]
|
| __getstate__(self) -> Mapping[str, Any]
| Helper for pickle.
|
| __init__(self, capacity: int) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self) -> Iterator[Any]
|
| __len__(self) -> int
| Return the current size of the cache.
|
| __repr__(self) -> str
| Return repr(self).
|
| __reversed__(self) -> Iterator[Any]
| Iterate over the keys in the cache dict, oldest items
| coming first.
|
| __setitem__(self, key: Any, value: Any) -> None
| Sets the value for an item. Moves the item up so that it
| has the highest priority then.
|
| __setstate__(self, d: Mapping[str, Any]) -> None
|
| clear(self) -> None
| Clear the cache.
|
| copy(self) -> 'LRUCache'
| Return a shallow copy of the instance.
|
| get(self, key: Any, default: Any = None) -> Any
| Return an item from the cache dict or `default`
|
| items(self) -> Iterable[Tuple[Any, Any]]
| Return a list of items.
|
| keys(self) -> Iterable[Any]
| Return a list of all keys ordered by most recent usage.
|
| setdefault(self, key: Any, default: Any = None) -> Any
| Set `default` if the key is not in the cache otherwise
| leave unchanged. Return the value of this key.
|
| values(self) -> Iterable[Any]
| Return a list of all values.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Namespace(builtins.object)
| Namespace(*args: Any, **kwargs: Any) -> None
|
| A namespace object that can hold arbitrary attributes. It may be
| initialized from a dictionary or with keyword arguments.
|
| Methods defined here:
|
| __getattribute__(self, name: str) -> Any
| Return getattr(self, name).
|
| __init__(*args: Any, **kwargs: Any) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> str
| Return repr(self).
|
| __setitem__(self, name: str, value: Any) -> None
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
Lock = allocate_lock(...)
allocate_lock() -> lock object
(allocate() is an obsolete synonym)
Create a new lock object. See help(type(threading.Lock())) for
information about locks.
clear_caches() -> None
Jinja keeps internal caches for environments and lexers. These are
used so that Jinja doesn't have to recreate environments and lexers all
the time. Normally you don't have to care about that but if you are
measuring memory consumption you may want to clean the caches.
concat = join(iterable, /) method of builtins.str instance
Concatenate any number of strings.
The string whose method is called is inserted in between each given string.
The result is returned as a new string.
Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
consume(iterable: Iterable[Any]) -> None
Consumes an iterable without doing anything with it.
generate_lorem_ipsum(n: int = 5, html: bool = True, min: int = 20, max: int = 100) -> str
Generate some lorem ipsum for the template.
htmlsafe_json_dumps(obj: Any, dumps: Optional[Callable[..., str]] = None, **kwargs: Any) -> markupsafe.Markup
Serialize an object to a string of JSON with :func:`json.dumps`,
then replace HTML-unsafe characters with Unicode escapes and mark
the result safe with :class:`~markupsafe.Markup`.
This is available in templates as the ``|tojson`` filter.
The following characters are escaped: ``<``, ``>``, ``&``, ``'``.
The returned string is safe to render in HTML documents and
``<script>`` tags. The exception is in HTML attributes that are
double quoted; either use single quotes or the ``|forceescape``
filter.
:param obj: The object to serialize to JSON.
:param dumps: The ``dumps`` function to use. Defaults to
``env.policies["json.dumps_function"]``, which defaults to
:func:`json.dumps`.
:param kwargs: Extra arguments to pass to ``dumps``. Merged onto
``env.policies["json.dumps_kwargs"]``.
.. versionchanged:: 3.0
The ``dumper`` parameter is renamed to ``dumps``.
.. versionadded:: 2.9
import_string(import_name: str, silent: bool = False) -> Any
Imports an object based on a string. This is useful if you want to
use import paths as endpoints or something similar. An import path can
be specified either in dotted notation (``xml.sax.saxutils.escape``)
or with a colon as object delimiter (``xml.sax.saxutils:escape``).
If the `silent` is True the return value will be `None` if the import
fails.
:return: imported object
internalcode(f: ~F) -> ~F
Marks the function as internally used
is_undefined(obj: Any) -> bool
Check if the object passed is undefined. This does nothing more than
performing an instance check against :class:`Undefined` but looks nicer.
This can be used for custom filters or tests that want to react to
undefined variables. For example a custom default filter can look like
this::
def default(var, default=''):
if is_undefined(var):
return default
return var
object_type_repr(obj: Any) -> str
Returns the name of the object's type. For some recognized
singletons the name of the object is returned instead. (For
example for `None` and `Ellipsis`).
open_if_exists(filename: str, mode: str = 'rb') -> Optional[IO[Any]]
Returns a file descriptor for the filename if that file exists,
otherwise ``None``.
pass_context(f: ~F) -> ~F
Pass the :class:`~jinja2.runtime.Context` as the first argument
to the decorated function when called while rendering a template.
Can be used on functions, filters, and tests.
If only ``Context.eval_context`` is needed, use
:func:`pass_eval_context`. If only ``Context.environment`` is
needed, use :func:`pass_environment`.
.. versionadded:: 3.0.0
Replaces ``contextfunction`` and ``contextfilter``.
pass_environment(f: ~F) -> ~F
Pass the :class:`~jinja2.Environment` as the first argument to
the decorated function when called while rendering a template.
Can be used on functions, filters, and tests.
.. versionadded:: 3.0.0
Replaces ``environmentfunction`` and ``environmentfilter``.
pass_eval_context(f: ~F) -> ~F
Pass the :class:`~jinja2.nodes.EvalContext` as the first argument
to the decorated function when called while rendering a template.
See :ref:`eval-context`.
Can be used on functions, filters, and tests.
If only ``EvalContext.environment`` is needed, use
:func:`pass_environment`.
.. versionadded:: 3.0.0
Replaces ``evalcontextfunction`` and ``evalcontextfilter``.
pformat(obj: Any) -> str
Format an object using :func:`pprint.pformat`.
select_autoescape(enabled_extensions: Collection[str] = ('html', 'htm', 'xml'), disabled_extensions: Collection[str] = (), default_for_string: bool = True, default: bool = False) -> Callable[[Optional[str]], bool]
Intelligently sets the initial value of autoescaping based on the
filename of the template. This is the recommended way to configure
autoescaping if you do not want to write a custom function yourself.
If you want to enable it for all templates created from strings or
for all templates with `.html` and `.xml` extensions::
from jinja2 import Environment, select_autoescape
env = Environment(autoescape=select_autoescape(
enabled_extensions=('html', 'xml'),
default_for_string=True,
))
Example configuration to turn it on at all times except if the template
ends with `.txt`::
from jinja2 import Environment, select_autoescape
env = Environment(autoescape=select_autoescape(
disabled_extensions=('txt',),
default_for_string=True,
default=True,
))
The `enabled_extensions` is an iterable of all the extensions that
autoescaping should be enabled for. Likewise `disabled_extensions` is
a list of all templates it should be disabled for. If a template is
loaded from a string then the default from `default_for_string` is used.
If nothing matches then the initial value of autoescaping is set to the
value of `default`.
For security reasons this function operates case insensitive.
.. versionadded:: 2.9
url_quote(obj: Any, charset: str = 'utf-8', for_qs: bool = False) -> str
Quote a string for use in a URL using the given charset.
:param obj: String or bytes to quote. Other types are converted to
string then encoded to bytes using the given charset.
:param charset: Encode text to bytes using this charset.
:param for_qs: Quote "/" and use "+" for spaces.
urlize(text: str, trim_url_limit: Optional[int] = None, rel: Optional[str] = None, target: Optional[str] = None, extra_schemes: Optional[Iterable[str]] = None) -> str
Convert URLs in text into clickable links.
This may not recognize links in some situations. Usually, a more
comprehensive formatter, such as a Markdown library, is a better
choice.
Works on ``http://``, ``https://``, ``www.``, ``mailto:``, and email
addresses. Links with trailing punctuation (periods, commas, closing
parentheses) and leading punctuation (opening parentheses) are
recognized excluding the punctuation. Email addresses that include
header fields are not recognized (for example,
``mailto:address@example.com?cc=copy@example.com``).
:param text: Original text containing URLs to link.
:param trim_url_limit: Shorten displayed URL values to this length.
:param target: Add the ``target`` attribute to links.
:param rel: Add the ``rel`` attribute to links.
:param extra_schemes: Recognize URLs that start with these schemes
in addition to the default behavior.
.. versionchanged:: 3.0
The ``extra_schemes`` parameter was added.
.. versionchanged:: 3.0
Generate ``https://`` links for URLs without a scheme.
.. versionchanged:: 3.0
The parsing rules were updated. Recognize email addresses with
or without the ``mailto:`` scheme. Validate IP addresses. Ignore
parentheses and brackets in more cases.
DATA
F = ~F
__annotations__ = {'internal_code': typing.MutableSet[code], 'missing'...
internal_code = {<code object _get_default_module at 0x000001ED6A...\s...
missing = missing
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\utils.py
jinja2.visitor
Python Library Documentation: module jinja2.visitor in jinja2
NAME
jinja2.visitor
DESCRIPTION
API for traversing the AST nodes. Implemented by the compiler and
meta introspection.
CLASSES
builtins.object
NodeVisitor
NodeTransformer
class NodeTransformer(NodeVisitor)
| Walks the abstract syntax tree and allows modifications of nodes.
|
| The `NodeTransformer` will walk the AST and use the return value of the
| visitor functions to replace or remove the old node. If the return
| value of the visitor function is `None` the node will be removed
| from the previous location otherwise it's replaced with the return
| value. The return value may be the original node in which case no
| replacement takes place.
|
| Method resolution order:
| NodeTransformer
| NodeVisitor
| builtins.object
|
| Methods defined here:
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> jinja2.nodes.Node
| Called if no explicit visitor function exists for a node.
|
| visit_list(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> List[jinja2.nodes.Node]
| As transformers may return lists in some places this method
| can be used to enforce a list as return value.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from NodeVisitor:
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from NodeVisitor:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class NodeVisitor(builtins.object)
| Walks the abstract syntax tree and call visitor functions for every
| node found. The visitor functions may return values which will be
| forwarded by the `visit` method.
|
| Per default the visitor functions for the nodes are ``'visit_'`` +
| class name of the node. So a `TryFinally` node visit function would
| be `visit_TryFinally`. This behavior can be changed by overriding
| the `get_visitor` function. If no visitor function exists for a node
| (return value `None`) the `generic_visit` visitor is used instead.
|
| Methods defined here:
|
| generic_visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Called if no explicit visitor function exists for a node.
|
| get_visitor(self, node: jinja2.nodes.Node) -> 't.Optional[VisitCallable]'
| Return the visitor function for this node or `None` if no visitor
| exists for this node. In that case the generic visit function is
| used instead.
|
| visit(self, node: jinja2.nodes.Node, *args: Any, **kwargs: Any) -> Any
| Visit a node.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\jinja2\visitor.py