SYMBOL INDEX (1684 symbols across 48 files) FILE: docs/examples/cache_extension.py class FragmentCacheExtension (line 5) | class FragmentCacheExtension(Extension): method __init__ (line 9) | def __init__(self, environment): method parse (line 15) | def parse(self, parser): method _cache_support (line 42) | def _cache_support(self, name, timeout, caller): FILE: docs/examples/inline_gettext_extension.py class InlineGettext (line 12) | class InlineGettext(Extension): method filter_stream (line 21) | def filter_stream(self, stream): FILE: scripts/generate_identifier_pattern.py function get_characters (line 7) | def get_characters(): function collapse_ranges (line 26) | def collapse_ranges(data): function build_pattern (line 37) | def build_pattern(ranges): function main (line 56) | def main(): FILE: src/jinja2/__init__.py function __getattr__ (line 43) | def __getattr__(name: str) -> t.Any: FILE: src/jinja2/async_utils.py function async_variant (line 15) | def async_variant(normal_func): # type: ignore function auto_await (line 62) | async def auto_await(value: t.Union[t.Awaitable["V"], "V"]) -> "V": class _IteratorToAsyncIterator (line 73) | class _IteratorToAsyncIterator(t.Generic[V]): method __init__ (line 74) | def __init__(self, iterator: "t.Iterator[V]"): method __aiter__ (line 77) | def __aiter__(self) -> "te.Self": method __anext__ (line 80) | async def __anext__(self) -> V: function auto_aiter (line 87) | def auto_aiter( function auto_to_list (line 96) | async def auto_to_list( FILE: src/jinja2/bccache.py class _MemcachedClient (line 27) | class _MemcachedClient(te.Protocol): method get (line 28) | def get(self, key: str) -> bytes: ... method set (line 30) | def set(self, key: str, value: bytes, timeout: int | None = None) -> N... class Bucket (line 44) | class Bucket: method __init__ (line 53) | def __init__(self, environment: "Environment", key: str, checksum: str... method reset (line 59) | def reset(self) -> None: method load_bytecode (line 63) | def load_bytecode(self, f: t.BinaryIO) -> None: method write_bytecode (line 82) | def write_bytecode(self, f: t.IO[bytes]) -> None: method bytecode_from_string (line 90) | def bytecode_from_string(self, string: bytes) -> None: method bytecode_to_string (line 94) | def bytecode_to_string(self) -> bytes: class BytecodeCache (line 101) | class BytecodeCache: method load_bytecode (line 130) | def load_bytecode(self, bucket: Bucket) -> None: method dump_bytecode (line 137) | def dump_bytecode(self, bucket: Bucket) -> None: method clear (line 144) | def clear(self) -> None: method get_cache_key (line 150) | def get_cache_key(self, name: str, filename: str | None = None) -> str: method get_source_checksum (line 159) | def get_source_checksum(self, source: str) -> str: method get_bucket (line 163) | def get_bucket( method set_bucket (line 179) | def set_bucket(self, bucket: Bucket) -> None: class FileSystemBytecodeCache (line 184) | class FileSystemBytecodeCache(BytecodeCache): method __init__ (line 202) | def __init__( method _get_default_cache_dir (line 210) | def _get_default_cache_dir(self) -> str: method _get_cache_filename (line 257) | def _get_cache_filename(self, bucket: Bucket) -> str: method load_bytecode (line 260) | def load_bytecode(self, bucket: Bucket) -> None: method dump_bytecode (line 275) | def dump_bytecode(self, bucket: Bucket) -> None: method clear (line 313) | def clear(self) -> None: class MemcachedBytecodeCache (line 327) | class MemcachedBytecodeCache(BytecodeCache): method __init__ (line 372) | def __init__( method load_bytecode (line 384) | def load_bytecode(self, bucket: Bucket) -> None: method dump_bytecode (line 393) | def dump_bytecode(self, bucket: Bucket) -> None: FILE: src/jinja2/compiler.py function optimizeconst (line 45) | def optimizeconst(f: F) -> F: function _make_binop (line 61) | def _make_binop(op: str) -> t.Callable[["CodeGenerator", nodes.BinExpr, ... function _make_unop (line 82) | def _make_unop( function generate (line 101) | def generate( function has_safe_repr (line 125) | def has_safe_repr(value: t.Any) -> bool: function find_undeclared (line 142) | def find_undeclared(nodes: t.Iterable[nodes.Node], names: t.Iterable[str... class MacroRef (line 155) | class MacroRef: method __init__ (line 156) | def __init__(self, node: nodes.Macro | nodes.CallBlock) -> None: class Frame (line 163) | class Frame: method __init__ (line 166) | def __init__( method copy (line 217) | def copy(self) -> "te.Self": method inner (line 224) | def inner(self, isolated: bool = False) -> "Frame": method soft (line 230) | def soft(self) -> "te.Self": class VisitorExit (line 246) | class VisitorExit(RuntimeError): class DependencyFinderVisitor (line 250) | class DependencyFinderVisitor(NodeVisitor): method __init__ (line 253) | def __init__(self) -> None: method visit_Filter (line 257) | def visit_Filter(self, node: nodes.Filter) -> None: method visit_Test (line 261) | def visit_Test(self, node: nodes.Test) -> None: method visit_Block (line 265) | def visit_Block(self, node: nodes.Block) -> None: class UndeclaredNameVisitor (line 269) | class UndeclaredNameVisitor(NodeVisitor): method __init__ (line 275) | def __init__(self, names: t.Iterable[str]) -> None: method visit_Name (line 279) | def visit_Name(self, node: nodes.Name) -> None: method visit_Block (line 287) | def visit_Block(self, node: nodes.Block) -> None: class CompilerExit (line 291) | class CompilerExit(Exception): class CodeGenerator (line 298) | class CodeGenerator(NodeVisitor): method __init__ (line 299) | def __init__( method optimized (line 373) | def optimized(self) -> bool: method fail (line 378) | def fail(self, msg: str, lineno: int) -> "te.NoReturn": method temporary_identifier (line 382) | def temporary_identifier(self) -> str: method buffer (line 387) | def buffer(self, frame: Frame) -> None: method return_buffer_contents (line 392) | def return_buffer_contents( method indent (line 412) | def indent(self) -> None: method outdent (line 416) | def outdent(self, step: int = 1) -> None: method start_write (line 420) | def start_write(self, frame: Frame, node: nodes.Node | None = None) ->... method end_write (line 427) | def end_write(self, frame: Frame) -> None: method simple_write (line 432) | def simple_write( method blockvisit (line 440) | def blockvisit(self, nodes: t.Iterable[nodes.Node], frame: Frame) -> N... method write (line 451) | def write(self, x: str) -> None: method writeline (line 465) | def writeline(self, x: str, node: nodes.Node | None = None, extra: int... method newline (line 470) | def newline(self, node: nodes.Node | None = None, extra: int = 0) -> N... method signature (line 477) | def signature( method pull_dependencies (line 534) | def pull_dependencies(self, nodes: t.Iterable[nodes.Node]) -> None: method enter_frame (line 580) | def enter_frame(self, frame: Frame) -> None: method leave_frame (line 596) | def leave_frame(self, frame: Frame, with_python_scope: bool = False) -... method choose_async (line 604) | def choose_async(self, async_value: str = "async ", sync_value: str = ... method func (line 607) | def func(self, name: str) -> str: method macro_body (line 610) | def macro_body( method macro_def (line 693) | def macro_def(self, macro_ref: MacroRef, frame: Frame) -> None: method position (line 705) | def position(self, node: nodes.Node) -> str: method dump_local_context (line 712) | def dump_local_context(self, frame: Frame) -> str: method write_commons (line 719) | def write_commons(self) -> None: method push_parameter_definitions (line 732) | def push_parameter_definitions(self, frame: Frame) -> None: method pop_parameter_definitions (line 741) | def pop_parameter_definitions(self) -> None: method mark_parameter_stored (line 745) | def mark_parameter_stored(self, target: str) -> None: method push_context_reference (line 752) | def push_context_reference(self, target: str) -> None: method pop_context_reference (line 755) | def pop_context_reference(self) -> None: method get_context_ref (line 758) | def get_context_ref(self) -> str: method get_resolve_func (line 761) | def get_resolve_func(self) -> str: method derive_context (line 767) | def derive_context(self, frame: Frame) -> str: method parameter_is_undeclared (line 770) | def parameter_is_undeclared(self, target: str) -> bool: method push_assign_tracking (line 776) | def push_assign_tracking(self) -> None: method pop_assign_tracking (line 780) | def pop_assign_tracking(self, frame: Frame) -> None: method visit_Template (line 825) | def visit_Template(self, node: nodes.Template, frame: Frame | None = N... method visit_Block (line 945) | def visit_Block(self, node: nodes.Block, frame: Frame) -> None: method visit_Extends (line 994) | def visit_Extends(self, node: nodes.Extends, frame: Frame) -> None: method visit_Include (line 1036) | def visit_Include(self, node: nodes.Include, frame: Frame) -> None: method _import_common (line 1094) | def _import_common( method visit_Import (line 1109) | def visit_Import(self, node: nodes.Import, frame: Frame) -> None: method visit_FromImport (line 1120) | def visit_FromImport(self, node: nodes.FromImport, frame: Frame) -> None: method visit_For (line 1175) | def visit_For(self, node: nodes.For, frame: Frame) -> None: method visit_If (line 1314) | def visit_If(self, node: nodes.If, frame: Frame) -> None: method visit_Macro (line 1335) | def visit_Macro(self, node: nodes.Macro, frame: Frame) -> None: method visit_CallBlock (line 1345) | def visit_CallBlock(self, node: nodes.CallBlock, frame: Frame) -> None: method visit_FilterBlock (line 1353) | def visit_FilterBlock(self, node: nodes.FilterBlock, frame: Frame) -> ... method visit_With (line 1364) | def visit_With(self, node: nodes.With, frame: Frame) -> None: method visit_ExprStmt (line 1376) | def visit_ExprStmt(self, node: nodes.ExprStmt, frame: Frame) -> None: class _FinalizeInfo (line 1380) | class _FinalizeInfo(t.NamedTuple): method _default_finalize (line 1385) | def _default_finalize(value: t.Any) -> t.Any: method _make_finalize (line 1394) | def _make_finalize(self) -> _FinalizeInfo: method _output_const_repr (line 1442) | def _output_const_repr(self, group: t.Iterable[t.Any]) -> str: method _output_child_to_const (line 1449) | def _output_child_to_const( method _output_child_pre (line 1470) | def _output_child_pre( method _output_child_post (line 1486) | def _output_child_post( method visit_Output (line 1497) | def visit_Output(self, node: nodes.Output, frame: Frame) -> None: method visit_Assign (line 1576) | def visit_Assign(self, node: nodes.Assign, frame: Frame) -> None: method visit_AssignBlock (line 1607) | def visit_AssignBlock(self, node: nodes.AssignBlock, frame: Frame) -> ... method visit_Name (line 1631) | def visit_Name(self, node: nodes.Name, frame: Frame) -> None: method visit_NSRef (line 1656) | def visit_NSRef(self, node: nodes.NSRef, frame: Frame) -> None: method visit_Const (line 1664) | def visit_Const(self, node: nodes.Const, frame: Frame) -> None: method visit_TemplateData (line 1671) | def visit_TemplateData(self, node: nodes.TemplateData, frame: Frame) -... method visit_Tuple (line 1679) | def visit_Tuple(self, node: nodes.Tuple, frame: Frame) -> None: method visit_List (line 1688) | def visit_List(self, node: nodes.List, frame: Frame) -> None: method visit_Dict (line 1696) | def visit_Dict(self, node: nodes.Dict, frame: Frame) -> None: method visit_Concat (line 1720) | def visit_Concat(self, node: nodes.Concat, frame: Frame) -> None: method visit_Compare (line 1734) | def visit_Compare(self, node: nodes.Compare, frame: Frame) -> None: method visit_Operand (line 1741) | def visit_Operand(self, node: nodes.Operand, frame: Frame) -> None: method visit_Getattr (line 1746) | def visit_Getattr(self, node: nodes.Getattr, frame: Frame) -> None: method visit_Getitem (line 1758) | def visit_Getitem(self, node: nodes.Getitem, frame: Frame) -> None: method visit_Slice (line 1778) | def visit_Slice(self, node: nodes.Slice, frame: Frame) -> None: method _filter_test_common (line 1789) | def _filter_test_common( method visit_Filter (line 1831) | def visit_Filter(self, node: nodes.Filter, frame: Frame) -> None: method visit_Test (line 1848) | def visit_Test(self, node: nodes.Test, frame: Frame) -> None: method visit_CondExpr (line 1853) | def visit_CondExpr(self, node: nodes.CondExpr, frame: Frame) -> None: method visit_Call (line 1876) | def visit_Call( method visit_Keyword (line 1898) | def visit_Keyword(self, node: nodes.Keyword, frame: Frame) -> None: method visit_MarkSafe (line 1904) | def visit_MarkSafe(self, node: nodes.MarkSafe, frame: Frame) -> None: method visit_MarkSafeIfAutoescape (line 1909) | def visit_MarkSafeIfAutoescape( method visit_EnvironmentAttribute (line 1916) | def visit_EnvironmentAttribute( method visit_ExtensionAttribute (line 1921) | def visit_ExtensionAttribute( method visit_ImportedName (line 1926) | def visit_ImportedName(self, node: nodes.ImportedName, frame: Frame) -... method visit_InternalName (line 1929) | def visit_InternalName(self, node: nodes.InternalName, frame: Frame) -... method visit_ContextReference (line 1932) | def visit_ContextReference( method visit_DerivedContextReference (line 1937) | def visit_DerivedContextReference( method visit_Continue (line 1942) | def visit_Continue(self, node: nodes.Continue, frame: Frame) -> None: method visit_Break (line 1945) | def visit_Break(self, node: nodes.Break, frame: Frame) -> None: method visit_Scope (line 1948) | def visit_Scope(self, node: nodes.Scope, frame: Frame) -> None: method visit_OverlayScope (line 1955) | def visit_OverlayScope(self, node: nodes.OverlayScope, frame: Frame) -... method visit_EvalContextModifier (line 1969) | def visit_EvalContextModifier( method visit_ScopedEvalContextModifier (line 1982) | def visit_ScopedEvalContextModifier( FILE: src/jinja2/debug.py function rewrite_traceback_stack (line 14) | def rewrite_traceback_stack(source: str | None = None) -> BaseException: function fake_traceback (line 76) | def fake_traceback( # type: ignore function get_template_locals (line 131) | def get_template_locals(real_locals: t.Mapping[str, t.Any]) -> dict[str,... FILE: src/jinja2/environment.py function get_spontaneous_environment (line 70) | def get_spontaneous_environment(cls: type[_env_bound], *args: t.Any) -> ... function create_cache (line 83) | def create_cache( function copy_cache (line 96) | def copy_cache( function load_extensions (line 109) | def load_extensions( function _environment_config_check (line 127) | def _environment_config_check(environment: _env_bound) -> _env_bound: class Environment (line 145) | class Environment: method __init__ (line 295) | def __init__( method add_extension (line 371) | def add_extension(self, extension: str | type["Extension"]) -> None: method extend (line 378) | def extend(self, **attributes: t.Any) -> None: method overlay (line 387) | def overlay( method lexer (line 459) | def lexer(self) -> Lexer: method iter_extensions (line 463) | def iter_extensions(self) -> t.Iterator["Extension"]: method getitem (line 467) | def getitem(self, obj: t.Any, argument: str | t.Any) -> t.Any | Undefi... method getattr (line 484) | def getattr(self, obj: t.Any, attribute: str) -> t.Any: method _filter_test_common (line 497) | def _filter_test_common( method call_filter (line 551) | def call_filter( method call_test (line 572) | def call_test( method parse (line 598) | def parse( method _parse (line 617) | def _parse( method lex (line 623) | def lex( method preprocess (line 644) | def preprocess( method _tokenize (line 660) | def _tokenize( method _generate (line 681) | def _generate( method _compile (line 702) | def _compile(self, source: str, filename: str) -> CodeType: method compile (line 711) | def compile( method compile (line 721) | def compile( method compile (line 731) | def compile( method compile_expression (line 772) | def compile_expression( method compile_templates (line 817) | def compile_templates( method list_templates (line 898) | def list_templates( method handle_exception (line 935) | def handle_exception(self, source: str | None = None) -> "te.NoReturn": method join_path (line 943) | def join_path(self, template: str, parent: str) -> str: method _load_template (line 956) | def _load_template( method get_template (line 981) | def get_template( method select_template (line 1018) | def select_template( method get_or_select_template (line 1072) | def get_or_select_template( method from_string (line 1089) | def from_string( method make_globals (line 1110) | def make_globals( class Template (line 1133) | class Template: method __new__ (line 1164) | def __new__( method from_code (line 1214) | def from_code( method from_module_dict (line 1231) | def from_module_dict( method _from_namespace (line 1245) | def _from_namespace( method render (line 1272) | def render(self, *args: t.Any, **kwargs: t.Any) -> str: method render_async (line 1294) | async def render_async(self, *args: t.Any, **kwargs: t.Any) -> str: method stream (line 1317) | def stream(self, *args: t.Any, **kwargs: t.Any) -> "TemplateStream": method generate (line 1323) | def generate(self, *args: t.Any, **kwargs: t.Any) -> t.Iterator[str]: method generate_async (line 1347) | async def generate_async( method new_context (line 1369) | def new_context( method make_module (line 1386) | def make_module( method make_module_async (line 1401) | async def make_module_async( method _get_default_module (line 1420) | def _get_default_module(self, ctx: Context | None = None) -> "Template... method _get_default_module_async (line 1446) | async def _get_default_module_async( method module (line 1461) | def module(self) -> "TemplateModule": method get_corresponding_lineno (line 1476) | def get_corresponding_lineno(self, lineno: int) -> int: method is_up_to_date (line 1486) | def is_up_to_date(self) -> bool: method debug_info (line 1493) | def debug_info(self) -> list[tuple[int, int]]: method __repr__ (line 1503) | def __repr__(self) -> str: class TemplateModule (line 1511) | class TemplateModule: method __init__ (line 1517) | def __init__( method __html__ (line 1537) | def __html__(self) -> Markup: method __str__ (line 1540) | def __str__(self) -> str: method __repr__ (line 1543) | def __repr__(self) -> str: class TemplateExpression (line 1551) | class TemplateExpression: method __init__ (line 1557) | def __init__(self, template: Template, undefined_to_none: bool) -> None: method __call__ (line 1561) | def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any | None: class TemplateStream (line 1570) | class TemplateStream: method __init__ (line 1581) | def __init__(self, gen: t.Iterator[str]) -> None: method dump (line 1585) | def dump( method disable_buffering (line 1625) | def disable_buffering(self) -> None: method _buffered_generator (line 1630) | def _buffered_generator(self, size: int) -> t.Iterator[str]: method enable_buffering (line 1649) | def enable_buffering(self, size: int = 5) -> None: method __iter__ (line 1657) | def __iter__(self) -> "TemplateStream": method __next__ (line 1660) | def __next__(self) -> str: FILE: src/jinja2/exceptions.py class TemplateError (line 7) | class TemplateError(Exception): method __init__ (line 10) | def __init__(self, message: str | None = None) -> None: method message (line 14) | def message(self) -> str | None: class TemplateNotFound (line 18) | class TemplateNotFound(IOError, LookupError, TemplateError): method __init__ (line 30) | def __init__( method __str__ (line 49) | def __str__(self) -> str: class TemplatesNotFound (line 53) | class TemplatesNotFound(TemplateNotFound): method __init__ (line 65) | def __init__( class TemplateSyntaxError (line 88) | class TemplateSyntaxError(TemplateError): method __init__ (line 91) | def __init__( method __str__ (line 108) | def __str__(self) -> str: method __reduce__ (line 131) | def __reduce__(self): # type: ignore class TemplateAssertionError (line 139) | class TemplateAssertionError(TemplateSyntaxError): class TemplateRuntimeError (line 147) | class TemplateRuntimeError(TemplateError): class UndefinedError (line 153) | class UndefinedError(TemplateRuntimeError): class SecurityError (line 157) | class SecurityError(TemplateRuntimeError): class FilterArgumentError (line 163) | class FilterArgumentError(TemplateRuntimeError): FILE: src/jinja2/ext.py class _TranslationsBasic (line 27) | class _TranslationsBasic(te.Protocol): method gettext (line 28) | def gettext(self, message: str) -> str: ... method ngettext (line 30) | def ngettext(self, singular: str, plural: str, n: int) -> str: class _TranslationsContext (line 33) | class _TranslationsContext(_TranslationsBasic): method pgettext (line 34) | def pgettext(self, context: str, message: str) -> str: ... method npgettext (line 36) | def npgettext( class Extension (line 55) | class Extension: method __init_subclass__ (line 76) | def __init_subclass__(cls) -> None: method __init__ (line 89) | def __init__(self, environment: Environment) -> None: method bind (line 92) | def bind(self, environment: Environment) -> "te.Self": method preprocess (line 99) | def preprocess( method filter_stream (line 108) | def filter_stream( method parse (line 118) | def parse(self, parser: "Parser") -> nodes.Node | list[nodes.Node]: method attr (line 126) | def attr(self, name: str, lineno: int | None = None) -> nodes.Extensio... method call_method (line 136) | def call_method( function _gettext_alias (line 163) | def _gettext_alias( function _make_new_gettext (line 169) | def _make_new_gettext(func: t.Callable[[str], str]) -> t.Callable[..., s... function _make_new_ngettext (line 183) | def _make_new_ngettext(func: t.Callable[[str, str, int], str]) -> t.Call... function _make_new_pgettext (line 202) | def _make_new_pgettext(func: t.Callable[[str, str], str]) -> t.Callable[... function _make_new_npgettext (line 219) | def _make_new_npgettext( class InternationalizationExtension (line 244) | class InternationalizationExtension(Extension): method __init__ (line 256) | def __init__(self, environment: Environment) -> None: method _install (line 268) | def _install( method _install_null (line 286) | def _install_null(self, newstyle: bool | None = None) -> None: method _install_callables (line 298) | def _install_callables( method _uninstall (line 322) | def _uninstall(self, translations: "_SupportedTranslations") -> None: method _extract (line 326) | def _extract( method parse (line 335) | def parse(self, parser: "Parser") -> nodes.Node | list[nodes.Node]: method _trim_whitespace (line 457) | def _trim_whitespace(self, string: str, _ws_re: t.Pattern[str] = _ws_r... method _parse_block (line 460) | def _parse_block( method _make_node (line 507) | def _make_node( class ExprStmtExtension (line 570) | class ExprStmtExtension(Extension): method parse (line 577) | def parse(self, parser: "Parser") -> nodes.ExprStmt: class LoopControlExtension (line 583) | class LoopControlExtension(Extension): method parse (line 588) | def parse(self, parser: "Parser") -> nodes.Break | nodes.Continue: class DebugExtension (line 595) | class DebugExtension(Extension): method parse (line 618) | def parse(self, parser: "Parser") -> nodes.Output: method _render (line 624) | def _render(self, context: Context) -> str: function extract_from_ast (line 635) | def extract_from_ast( class _CommentFinder (line 712) | class _CommentFinder: method __init__ (line 719) | def __init__( method find_backwards (line 727) | def find_backwards(self, offset: int) -> list[str]: method find_comments (line 743) | def find_comments(self, lineno: int) -> list[str]: function babel_extract (line 752) | def babel_extract( FILE: src/jinja2/filters.py class HasHTML (line 39) | class HasHTML(te.Protocol): method __html__ (line 40) | def __html__(self) -> str: function ignore_case (line 49) | def ignore_case(value: V) -> V: function make_attrgetter (line 58) | def make_attrgetter( function make_multi_attrgetter (line 86) | def make_multi_attrgetter( function _prepare_attribute_parts (line 127) | def _prepare_attribute_parts( function do_forceescape (line 139) | def do_forceescape(value: "str | HasHTML") -> Markup: function do_urlencode (line 147) | def do_urlencode( function do_replace (line 179) | def do_replace( function do_upper (line 214) | def do_upper(s: str) -> str: function do_lower (line 219) | def do_lower(s: str) -> str: function do_items (line 224) | def do_items(value: t.Mapping[K, V] | Undefined) -> t.Iterator[tuple[K, ... function do_xmlattr (line 260) | def do_xmlattr( function do_capitalize (line 321) | def do_capitalize(s: str) -> str: function do_title (line 331) | def do_title(s: str) -> str: function do_dictsort (line 344) | def do_dictsort( function do_sort (line 386) | def do_sort( function sync_do_unique (line 442) | def sync_do_unique( function do_unique (line 475) | async def do_unique( function _min_or_max (line 486) | def _min_or_max( function do_min (line 507) | def do_min( function do_max (line 527) | def do_max( function do_default (line 546) | def do_default( function sync_do_join (line 580) | def sync_do_join( function do_join (line 638) | async def do_join( function do_center (line 647) | def do_center(value: str, width: int = 80) -> str: function sync_do_first (line 653) | def sync_do_first(environment: "Environment", seq: "t.Iterable[V]") -> "... function do_first (line 662) | async def do_first( function do_last (line 672) | def do_last(environment: "Environment", seq: "t.Reversible[V]") -> "V | ... function do_random (line 692) | def do_random(context: "Context", seq: "t.Sequence[V]") -> "V | Undefined": function do_filesizeformat (line 700) | def do_filesizeformat(value: str | float | int, binary: bool = False) ->... function do_pprint (line 733) | def do_pprint(value: t.Any) -> str: function do_urlize (line 742) | def do_urlize( function do_indent (line 821) | def do_indent( function do_truncate (line 870) | def do_truncate( function do_wordwrap (line 918) | def do_wordwrap( function do_wordcount (line 976) | def do_wordcount(s: str) -> int: function do_int (line 981) | def do_int(value: t.Any, default: int = 0, base: int = 10) -> int: function do_float (line 1003) | def do_float(value: t.Any, default: float = 0.0) -> float: function do_format (line 1014) | def do_format(value: str, *args: t.Any, **kwargs: t.Any) -> str: function do_trim (line 1042) | def do_trim(value: str, chars: str | None = None) -> str: function do_striptags (line 1047) | def do_striptags(value: "str | HasHTML") -> str: function sync_do_slice (line 1055) | def sync_do_slice( function do_slice (line 1099) | async def do_slice( function do_batch (line 1107) | def do_batch( function do_round (line 1144) | def do_round( class _GroupTuple (line 1184) | class _GroupTuple(t.NamedTuple): method __repr__ (line 1190) | def __repr__(self) -> str: method __str__ (line 1193) | def __str__(self) -> str: function sync_do_groupby (line 1198) | def sync_do_groupby( function do_groupby (line 1282) | async def do_groupby( function sync_do_sum (line 1309) | def sync_do_sum( function do_sum (line 1336) | async def do_sum( function sync_do_list (line 1357) | def sync_do_list(value: "t.Iterable[V]") -> "list[V]": function do_list (line 1365) | async def do_list(value: "t.AsyncIterable[V] | t.Iterable[V]") -> "list[... function do_mark_safe (line 1369) | def do_mark_safe(value: str) -> Markup: function do_mark_unsafe (line 1376) | def do_mark_unsafe(value: str) -> str: function do_reverse (line 1382) | def do_reverse(value: str) -> str: ... function do_reverse (line 1386) | def do_reverse(value: "t.Iterable[V]") -> "t.Iterable[V]": ... function do_reverse (line 1389) | def do_reverse(value: str | t.Iterable[V]) -> str | t.Iterable[V]: function do_attr (line 1408) | def do_attr(environment: "Environment", obj: t.Any, name: str) -> Undefi... function sync_do_map (line 1431) | def sync_do_map( function sync_do_map (line 1441) | def sync_do_map( function sync_do_map (line 1451) | def sync_do_map( function do_map (line 1501) | def do_map( function do_map (line 1511) | def do_map( function do_map (line 1521) | async def do_map( function sync_do_select (line 1535) | def sync_do_select( function do_select (line 1566) | async def do_select( function sync_do_reject (line 1576) | def sync_do_reject( function do_reject (line 1602) | async def do_reject( function sync_do_selectattr (line 1612) | def sync_do_selectattr( function do_selectattr (line 1642) | async def do_selectattr( function sync_do_rejectattr (line 1652) | def sync_do_rejectattr( function do_rejectattr (line 1680) | async def do_rejectattr( function do_tojson (line 1690) | def do_tojson( function prepare_map (line 1718) | def prepare_map( function prepare_select_or_reject (line 1746) | def prepare_select_or_reject( function select_or_reject (line 1780) | def select_or_reject( function async_select_or_reject (line 1796) | async def async_select_or_reject( FILE: src/jinja2/idtracking.py function find_symbols (line 15) | def find_symbols( function symbols_for_node (line 25) | def symbols_for_node( class Symbols (line 33) | class Symbols: method __init__ (line 34) | def __init__( method analyze_node (line 49) | def analyze_node(self, node: nodes.Node, **kwargs: t.Any) -> None: method _define_ref (line 53) | def _define_ref(self, name: str, load: tuple[str, str | None] | None =... method find_load (line 60) | def find_load(self, target: str) -> t.Any | None: method find_ref (line 69) | def find_ref(self, name: str) -> str | None: method ref (line 78) | def ref(self, name: str) -> str: method copy (line 87) | def copy(self) -> "te.Self": method store (line 95) | def store(self, name: str) -> None: method declare_parameter (line 113) | def declare_parameter(self, name: str) -> str: method load (line 117) | def load(self, name: str) -> None: method branch_update (line 121) | def branch_update(self, branch_symbols: t.Sequence["Symbols"]) -> None: method dump_stores (line 145) | def dump_stores(self) -> dict[str, str]: method dump_param_targets (line 158) | def dump_param_targets(self) -> set[str]: class RootVisitor (line 172) | class RootVisitor(NodeVisitor): method __init__ (line 173) | def __init__(self, symbols: "Symbols") -> None: method _simple_visit (line 176) | def _simple_visit(self, node: nodes.Node, **kwargs: t.Any) -> None: method visit_AssignBlock (line 188) | def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) ... method visit_CallBlock (line 192) | def visit_CallBlock(self, node: nodes.CallBlock, **kwargs: t.Any) -> N... method visit_OverlayScope (line 196) | def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any... method visit_For (line 200) | def visit_For( method visit_With (line 220) | def visit_With(self, node: nodes.With, **kwargs: t.Any) -> None: method generic_visit (line 226) | def generic_visit(self, node: nodes.Node, *args: t.Any, **kwargs: t.An... class FrameSymbolVisitor (line 230) | class FrameSymbolVisitor(NodeVisitor): method __init__ (line 233) | def __init__(self, symbols: "Symbols") -> None: method visit_Name (line 236) | def visit_Name( method visit_NSRef (line 247) | def visit_NSRef(self, node: nodes.NSRef, **kwargs: t.Any) -> None: method visit_If (line 250) | def visit_If(self, node: nodes.If, **kwargs: t.Any) -> None: method visit_Macro (line 268) | def visit_Macro(self, node: nodes.Macro, **kwargs: t.Any) -> None: method visit_Import (line 271) | def visit_Import(self, node: nodes.Import, **kwargs: t.Any) -> None: method visit_FromImport (line 275) | def visit_FromImport(self, node: nodes.FromImport, **kwargs: t.Any) ->... method visit_Assign (line 284) | def visit_Assign(self, node: nodes.Assign, **kwargs: t.Any) -> None: method visit_For (line 289) | def visit_For(self, node: nodes.For, **kwargs: t.Any) -> None: method visit_CallBlock (line 295) | def visit_CallBlock(self, node: nodes.CallBlock, **kwargs: t.Any) -> N... method visit_FilterBlock (line 298) | def visit_FilterBlock(self, node: nodes.FilterBlock, **kwargs: t.Any) ... method visit_With (line 301) | def visit_With(self, node: nodes.With, **kwargs: t.Any) -> None: method visit_AssignBlock (line 305) | def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) ... method visit_Scope (line 309) | def visit_Scope(self, node: nodes.Scope, **kwargs: t.Any) -> None: method visit_Block (line 312) | def visit_Block(self, node: nodes.Block, **kwargs: t.Any) -> None: method visit_OverlayScope (line 315) | def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any... FILE: src/jinja2/lexer.py function _describe_token_type (line 165) | def _describe_token_type(token_type: str) -> str: function describe_token (line 185) | def describe_token(token: "Token") -> str: function describe_token_expr (line 193) | def describe_token_expr(expr: str) -> str: function count_newlines (line 206) | def count_newlines(value: str) -> int: function compile_rules (line 213) | def compile_rules(environment: "Environment") -> list[tuple[str, str]]: class Failure (line 254) | class Failure: method __init__ (line 259) | def __init__( method __call__ (line 265) | def __call__(self, lineno: int, filename: str | None) -> "te.NoReturn": class Token (line 269) | class Token(t.NamedTuple): method __str__ (line 274) | def __str__(self) -> str: method test (line 277) | def test(self, expr: str) -> bool: method test_any (line 292) | def test_any(self, *iterable: str) -> bool: class TokenStreamIterator (line 297) | class TokenStreamIterator: method __init__ (line 302) | def __init__(self, stream: "TokenStream") -> None: method __iter__ (line 305) | def __iter__(self) -> "TokenStreamIterator": method __next__ (line 308) | def __next__(self) -> Token: class TokenStream (line 319) | class TokenStream: method __init__ (line 325) | def __init__( method __iter__ (line 339) | def __iter__(self) -> TokenStreamIterator: method __bool__ (line 342) | def __bool__(self) -> bool: method eos (line 346) | def eos(self) -> bool: method push (line 350) | def push(self, token: Token) -> None: method look (line 354) | def look(self) -> Token: method skip (line 362) | def skip(self, n: int = 1) -> None: method next_if (line 367) | def next_if(self, expr: str) -> Token | None: method skip_if (line 376) | def skip_if(self, expr: str) -> bool: method __next__ (line 380) | def __next__(self) -> Token: method close (line 397) | def close(self) -> None: method expect (line 403) | def expect(self, expr: str) -> Token: function get_lexer (line 428) | def get_lexer(environment: "Environment") -> "Lexer": class OptionalLStrip (line 452) | class OptionalLStrip(tuple): # type: ignore[type-arg] method __new__ (line 461) | def __new__(cls, *members, **kwargs): # type: ignore class _Rule (line 465) | class _Rule(t.NamedTuple): class Lexer (line 471) | class Lexer: method __init__ (line 479) | def __init__(self, environment: "Environment") -> None: method _normalize_newlines (line 598) | def _normalize_newlines(self, value: str) -> str: method tokenize (line 604) | def tokenize( method wrap (line 615) | def wrap( method tokeniter (line 669) | def tokeniter( FILE: src/jinja2/loaders.py function split_template_path (line 25) | def split_template_path(template: str) -> list[str]: class BaseLoader (line 42) | class BaseLoader: method get_source (line 75) | def get_source( method list_templates (line 101) | def list_templates(self) -> list[str]: method load (line 108) | def load( class FileSystemLoader (line 152) | class FileSystemLoader(BaseLoader): method __init__ (line 179) | def __init__( method get_source (line 194) | def get_source( method list_templates (line 228) | def list_templates(self) -> list[str]: function _get_zipimporter_files (line 248) | def _get_zipimporter_files(z: t.Any) -> dict[str, object]: function _get_zipimporter_files (line 259) | def _get_zipimporter_files(z: t.Any) -> dict[str, object]: class PackageLoader (line 269) | class PackageLoader(BaseLoader): method __init__ (line 302) | def __init__( method get_source (line 365) | def get_source( method list_templates (line 403) | def list_templates(self) -> list[str]: class DictLoader (line 432) | class DictLoader(BaseLoader): method __init__ (line 441) | def __init__(self, mapping: t.Mapping[str, str]) -> None: method get_source (line 444) | def get_source( method list_templates (line 452) | def list_templates(self) -> list[str]: class FunctionLoader (line 456) | class FunctionLoader(BaseLoader): method __init__ (line 474) | def __init__( method get_source (line 483) | def get_source( class PrefixLoader (line 497) | class PrefixLoader(BaseLoader): method __init__ (line 512) | def __init__( method get_loader (line 518) | def get_loader(self, template: str) -> tuple[BaseLoader, str]: method get_source (line 526) | def get_source( method load (line 538) | def load( method list_templates (line 552) | def list_templates(self) -> list[str]: class ChoiceLoader (line 560) | class ChoiceLoader(BaseLoader): method __init__ (line 574) | def __init__(self, loaders: t.Sequence[BaseLoader]) -> None: method get_source (line 577) | def get_source( method load (line 588) | def load( method list_templates (line 601) | def list_templates(self) -> list[str]: class _TemplateModule (line 608) | class _TemplateModule(ModuleType): class ModuleLoader (line 612) | class ModuleLoader(BaseLoader): method __init__ (line 624) | def __init__( method get_template_key (line 652) | def get_template_key(name: str) -> str: method get_module_filename (line 656) | def get_module_filename(name: str) -> str: method load (line 660) | def load( FILE: src/jinja2/meta.py class TrackingCodeGenerator (line 15) | class TrackingCodeGenerator(CodeGenerator): method __init__ (line 18) | def __init__(self, environment: "Environment") -> None: method write (line 22) | def write(self, x: str) -> None: method enter_frame (line 25) | def enter_frame(self, frame: Frame) -> None: function find_undeclared_variables (line 34) | def find_undeclared_variables(ast: nodes.Template) -> set[str]: function find_referenced_templates (line 62) | def find_referenced_templates(ast: nodes.Template) -> t.Iterator[str | N... FILE: src/jinja2/nativetypes.py function native_concat (line 16) | def native_concat(values: t.Iterable[t.Any]) -> t.Any | None: class NativeCodeGenerator (line 50) | class NativeCodeGenerator(CodeGenerator): method _default_finalize (line 56) | def _default_finalize(value: t.Any) -> t.Any: method _output_const_repr (line 59) | def _output_const_repr(self, group: t.Iterable[t.Any]) -> str: method _output_child_to_const (line 62) | def _output_child_to_const( method _output_child_pre (line 75) | def _output_child_pre( method _output_child_post (line 81) | def _output_child_post( class NativeEnvironment (line 88) | class NativeEnvironment(Environment): class NativeTemplate (line 95) | class NativeTemplate(Template): method render (line 98) | def render(self, *args: t.Any, **kwargs: t.Any) -> t.Any: method render_async (line 114) | async def render_async(self, *args: t.Any, **kwargs: t.Any) -> t.Any: FILE: src/jinja2/nodes.py class Impossible (line 50) | class Impossible(Exception): class NodeType (line 54) | class NodeType(type): method __new__ (line 59) | def __new__(mcs, name, bases, d): # type: ignore class EvalContext (line 71) | class EvalContext: method __init__ (line 76) | def __init__( method save (line 86) | def save(self) -> t.Mapping[str, t.Any]: method revert (line 89) | def revert(self, old: t.Mapping[str, t.Any]) -> None: function get_eval_context (line 94) | def get_eval_context(node: "Node", ctx: EvalContext | None) -> EvalContext: class Node (line 105) | class Node(metaclass=NodeType): method __init__ (line 129) | def __init__(self, *fields: t.Any, **attributes: t.Any) -> None: method iter_fields (line 147) | def iter_fields( method iter_child_nodes (line 169) | def iter_child_nodes( method find (line 186) | def find(self, node_type: type[_NodeBound]) -> _NodeBound | None: method find_all (line 195) | def find_all( method set_ctx (line 206) | def set_ctx(self, ctx: str) -> "Node": method set_lineno (line 220) | def set_lineno(self, lineno: int, override: bool = False) -> "Node": method set_environment (line 231) | def set_environment(self, environment: "Environment") -> "Node": method __eq__ (line 240) | def __eq__(self, other: t.Any) -> bool: method __repr__ (line 248) | def __repr__(self) -> str: method dump (line 252) | def dump(self) -> str: class Stmt (line 282) | class Stmt(Node): class Helper (line 288) | class Helper(Node): class Template (line 294) | class Template(Node): class Output (line 303) | class Output(Stmt): class Extends (line 312) | class Extends(Stmt): class For (line 319) | class For(Stmt): class If (line 337) | class If(Stmt): class Macro (line 347) | class Macro(Stmt): class CallBlock (line 360) | class CallBlock(Stmt): class FilterBlock (line 372) | class FilterBlock(Stmt): class With (line 380) | class With(Stmt): class Block (line 393) | class Block(Stmt): class Include (line 407) | class Include(Stmt): class Import (line 416) | class Import(Stmt): class FromImport (line 425) | class FromImport(Stmt): class ExprStmt (line 443) | class ExprStmt(Stmt): class Assign (line 450) | class Assign(Stmt): class AssignBlock (line 458) | class AssignBlock(Stmt): class Expr (line 467) | class Expr(Node): method as_const (line 472) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: method can_assign (line 485) | def can_assign(self) -> bool: class BinExpr (line 490) | class BinExpr(Expr): method as_const (line 499) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class UnaryExpr (line 515) | class UnaryExpr(Expr): method as_const (line 523) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Name (line 539) | class Name(Expr): method can_assign (line 552) | def can_assign(self) -> bool: class NSRef (line 556) | class NSRef(Expr): method can_assign (line 563) | def can_assign(self) -> bool: class Literal (line 571) | class Literal(Expr): class Const (line 577) | class Const(Literal): method as_const (line 587) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: method from_untrusted (line 591) | def from_untrusted( class TemplateData (line 608) | class TemplateData(Literal): method as_const (line 614) | def as_const(self, eval_ctx: EvalContext | None = None) -> str: class Tuple (line 623) | class Tuple(Literal): method as_const (line 633) | def as_const(self, eval_ctx: EvalContext | None = None) -> tuple[t.Any... method can_assign (line 637) | def can_assign(self) -> bool: class List (line 644) | class List(Literal): method as_const (line 650) | def as_const(self, eval_ctx: EvalContext | None = None) -> list[t.Any]: class Dict (line 655) | class Dict(Literal): method as_const (line 663) | def as_const(self, eval_ctx: EvalContext | None = None) -> dict[t.Any,... class Pair (line 668) | class Pair(Helper): method as_const (line 675) | def as_const(self, eval_ctx: EvalContext | None = None) -> tuple[t.Any... class Keyword (line 680) | class Keyword(Helper): method as_const (line 687) | def as_const(self, eval_ctx: EvalContext | None = None) -> tuple[str, ... class CondExpr (line 692) | class CondExpr(Expr): method as_const (line 702) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: function args_as_const (line 714) | def args_as_const( class _FilterTestCommon (line 735) | class _FilterTestCommon(Expr): method as_const (line 746) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Filter (line 783) | class Filter(_FilterTestCommon): method as_const (line 793) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Test (line 800) | class Test(_FilterTestCommon): class Call (line 813) | class Call(Expr): class Getitem (line 829) | class Getitem(Expr): method as_const (line 837) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Getattr (line 851) | class Getattr(Expr): method as_const (line 861) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Slice (line 873) | class Slice(Expr): method as_const (line 883) | def as_const(self, eval_ctx: EvalContext | None = None) -> slice: class Concat (line 894) | class Concat(Expr): method as_const (line 902) | def as_const(self, eval_ctx: EvalContext | None = None) -> str: class Compare (line 907) | class Compare(Expr): method as_const (line 916) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Operand (line 935) | class Operand(Helper): class Mul (line 943) | class Mul(BinExpr): class Div (line 949) | class Div(BinExpr): class FloorDiv (line 955) | class FloorDiv(BinExpr): class Add (line 963) | class Add(BinExpr): class Sub (line 969) | class Sub(BinExpr): class Mod (line 975) | class Mod(BinExpr): class Pow (line 981) | class Pow(BinExpr): class And (line 987) | class And(BinExpr): method as_const (line 992) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Or (line 997) | class Or(BinExpr): method as_const (line 1002) | def as_const(self, eval_ctx: EvalContext | None = None) -> t.Any: class Not (line 1007) | class Not(UnaryExpr): class Neg (line 1013) | class Neg(UnaryExpr): class Pos (line 1019) | class Pos(UnaryExpr): class EnvironmentAttribute (line 1028) | class EnvironmentAttribute(Expr): class ExtensionAttribute (line 1037) | class ExtensionAttribute(Expr): class ImportedName (line 1050) | class ImportedName(Expr): class InternalName (line 1061) | class InternalName(Expr): method __init__ (line 1072) | def __init__(self) -> None: class MarkSafe (line 1079) | class MarkSafe(Expr): method as_const (line 1085) | def as_const(self, eval_ctx: EvalContext | None = None) -> Markup: class MarkSafeIfAutoescape (line 1090) | class MarkSafeIfAutoescape(Expr): method as_const (line 1100) | def as_const(self, eval_ctx: EvalContext | None = None) -> Markup | t.... class ContextReference (line 1110) | class ContextReference(Expr): class DerivedContextReference (line 1128) | class DerivedContextReference(Expr): class Continue (line 1137) | class Continue(Stmt): class Break (line 1141) | class Break(Stmt): class Scope (line 1145) | class Scope(Stmt): class OverlayScope (line 1152) | class OverlayScope(Stmt): class EvalContextModifier (line 1171) | class EvalContextModifier(Stmt): class ScopedEvalContextModifier (line 1184) | class ScopedEvalContextModifier(EvalContextModifier): function _failing_new (line 1195) | def _failing_new(*args: t.Any, **kwargs: t.Any) -> "te.NoReturn": FILE: src/jinja2/optimizer.py function optimize (line 20) | def optimize(node: nodes.Node, environment: "Environment") -> nodes.Node: class Optimizer (line 27) | class Optimizer(NodeTransformer): method __init__ (line 28) | def __init__(self, environment: "Environment | None") -> None: method generic_visit (line 31) | def generic_visit( FILE: src/jinja2/parser.py class Parser (line 48) | class Parser: method __init__ (line 53) | def __init__( method fail (line 76) | def fail( method _fail_ut_eof (line 90) | def _fail_ut_eof( method fail_unknown_tag (line 130) | def fail_unknown_tag(self, name: str, lineno: int | None = None) -> "t... method fail_eof (line 137) | def fail_eof( method is_tuple_end (line 148) | def is_tuple_end(self, extra_end_rules: tuple[str, ...] | None = None)... method free_identifier (line 156) | def free_identifier(self, lineno: int | None = None) -> nodes.Internal... method parse_statement (line 163) | def parse_statement(self) -> nodes.Node | list[nodes.Node]: method parse_statements (line 192) | def parse_statements( method parse_set (line 221) | def parse_set(self) -> nodes.Assign | nodes.AssignBlock: method parse_for (line 232) | def parse_for(self) -> nodes.For: method parse_if (line 251) | def parse_if(self) -> nodes.If: method parse_with (line 269) | def parse_with(self) -> nodes.With: method parse_autoescape (line 286) | def parse_autoescape(self) -> nodes.Scope: method parse_block (line 292) | def parse_block(self) -> nodes.Block: method parse_extends (line 324) | def parse_extends(self) -> nodes.Extends: method parse_import_context (line 329) | def parse_import_context( method parse_include (line 341) | def parse_include(self) -> nodes.Include: method parse_import (line 353) | def parse_import(self) -> nodes.Import: method parse_from (line 360) | def parse_from(self) -> nodes.FromImport: method parse_signature (line 402) | def parse_signature(self, node: _MacroCall) -> None: method parse_call_block (line 418) | def parse_call_block(self) -> nodes.CallBlock: method parse_filter_block (line 433) | def parse_filter_block(self) -> nodes.FilterBlock: method parse_macro (line 439) | def parse_macro(self) -> nodes.Macro: method parse_print (line 446) | def parse_print(self) -> nodes.Output: method parse_assign_target (line 456) | def parse_assign_target( method parse_assign_target (line 461) | def parse_assign_target( method parse_assign_target (line 469) | def parse_assign_target( method parse_expression (line 508) | def parse_expression(self, with_condexpr: bool = True) -> nodes.Expr: method parse_condexpr (line 517) | def parse_condexpr(self) -> nodes.Expr: method parse_or (line 532) | def parse_or(self) -> nodes.Expr: method parse_and (line 541) | def parse_and(self) -> nodes.Expr: method parse_not (line 550) | def parse_not(self) -> nodes.Expr: method parse_compare (line 556) | def parse_compare(self) -> nodes.Expr: method parse_math1 (line 579) | def parse_math1(self) -> nodes.Expr: method parse_concat (line 590) | def parse_concat(self) -> nodes.Expr: method parse_math2 (line 600) | def parse_math2(self) -> nodes.Expr: method parse_pow (line 611) | def parse_pow(self) -> nodes.Expr: method parse_unary (line 621) | def parse_unary(self, with_filter: bool = True) -> nodes.Expr: method parse_primary (line 639) | def parse_primary(self, with_namespace: bool = False) -> nodes.Expr: method parse_tuple (line 681) | def parse_tuple( method parse_list (line 750) | def parse_list(self) -> nodes.List: method parse_dict (line 762) | def parse_dict(self) -> nodes.Dict: method parse_postfix (line 777) | def parse_postfix(self, node: nodes.Expr) -> nodes.Expr: method parse_filter_expr (line 790) | def parse_filter_expr(self, node: nodes.Expr) -> nodes.Expr: method parse_subscript (line 805) | def parse_subscript(self, node: nodes.Expr) -> nodes.Getattr | nodes.G... method parse_subscribed (line 834) | def parse_subscribed(self) -> nodes.Expr: method parse_call_args (line 866) | def parse_call_args( method parse_call (line 922) | def parse_call(self, node: nodes.Expr) -> nodes.Call: method parse_filter (line 929) | def parse_filter( method parse_test (line 952) | def parse_test(self, node: nodes.Expr) -> nodes.Expr: method subparse (line 990) | def subparse(self, end_tokens: tuple[str, ...] | None = None) -> list[... method parse (line 1037) | def parse(self) -> nodes.Template: FILE: src/jinja2/runtime.py class LoopRenderFunc (line 37) | class LoopRenderFunc(te.Protocol): method __call__ (line 38) | def __call__( function identity (line 70) | def identity(x: V) -> V: function markup_join (line 77) | def markup_join(seq: t.Iterable[t.Any]) -> str: function str_join (line 88) | def str_join(seq: t.Iterable[t.Any]) -> str: function new_context (line 93) | def new_context( class TemplateReference (line 122) | class TemplateReference: method __init__ (line 125) | def __init__(self, context: "Context") -> None: method __getitem__ (line 128) | def __getitem__(self, name: str) -> t.Any: method __repr__ (line 132) | def __repr__(self) -> str: function _dict_method_all (line 136) | def _dict_method_all(dict_method: F) -> F: class Context (line 145) | class Context: method __init__ (line 165) | def __init__( method super (line 186) | def super( method get (line 200) | def get(self, key: str, default: t.Any = None) -> t.Any: method resolve (line 212) | def resolve(self, key: str) -> t.Union[t.Any, "Undefined"]: method resolve_or_missing (line 229) | def resolve_or_missing(self, key: str) -> t.Any: method get_exported (line 247) | def get_exported(self) -> dict[str, t.Any]: method get_all (line 251) | def get_all(self) -> dict[str, t.Any]: method call (line 263) | def call( method derived (line 310) | def derived(self, locals: dict[str, t.Any] | None = None) -> "Context": method __contains__ (line 326) | def __contains__(self, name: str) -> bool: method __getitem__ (line 329) | def __getitem__(self, key: str) -> t.Any: method __repr__ (line 340) | def __repr__(self) -> str: class BlockReference (line 344) | class BlockReference: method __init__ (line 347) | def __init__( method super (line 360) | def super(self) -> t.Union["BlockReference", "Undefined"]: method _async_call (line 369) | async def _async_call(self) -> str: method __call__ (line 380) | def __call__(self) -> str: class LoopContext (line 394) | class LoopContext: method __init__ (line 408) | def __init__( method _to_iterator (line 431) | def _to_iterator(iterable: t.Iterable[V]) -> t.Iterator[V]: method length (line 435) | def length(self) -> int: method __len__ (line 453) | def __len__(self) -> int: method depth (line 457) | def depth(self) -> int: method index (line 462) | def index(self) -> int: method revindex0 (line 467) | def revindex0(self) -> int: method revindex (line 475) | def revindex(self) -> int: method first (line 483) | def first(self) -> bool: method _peek_next (line 487) | def _peek_next(self) -> t.Any: method last (line 500) | def last(self) -> bool: method previtem (line 510) | def previtem(self) -> t.Union[t.Any, "Undefined"]: method nextitem (line 520) | def nextitem(self) -> t.Union[t.Any, "Undefined"]: method cycle (line 535) | def cycle(self, *args: V) -> V: method changed (line 546) | def changed(self, *value: t.Any) -> bool: method __iter__ (line 558) | def __iter__(self) -> "LoopContext": method __next__ (line 561) | def __next__(self) -> tuple[t.Any, "LoopContext"]: method __call__ (line 574) | def __call__(self, iterable: t.Iterable[V]) -> str: method __repr__ (line 587) | def __repr__(self) -> str: class AsyncLoopContext (line 591) | class AsyncLoopContext(LoopContext): method _to_iterator (line 595) | def _to_iterator( # type: ignore method length (line 601) | async def length(self) -> int: # type: ignore method revindex0 (line 615) | async def revindex0(self) -> int: # type: ignore method revindex (line 619) | async def revindex(self) -> int: # type: ignore method _peek_next (line 622) | async def _peek_next(self) -> t.Any: method last (line 634) | async def last(self) -> bool: # type: ignore method nextitem (line 638) | async def nextitem(self) -> t.Union[t.Any, "Undefined"]: method __aiter__ (line 646) | def __aiter__(self) -> "AsyncLoopContext": method __anext__ (line 649) | async def __anext__(self) -> tuple[t.Any, "AsyncLoopContext"]: class Macro (line 662) | class Macro: method __init__ (line 665) | def __init__( method __call__ (line 696) | def __call__(self, *args: t.Any, **kwargs: t.Any) -> str: method _async_invoke (line 772) | async def _async_invoke(self, arguments: list[t.Any], autoescape: bool... method _invoke (line 780) | def _invoke(self, arguments: list[t.Any], autoescape: bool) -> str: method __repr__ (line 791) | def __repr__(self) -> str: class Undefined (line 796) | class Undefined: method __init__ (line 818) | def __init__( method _undefined_message (line 831) | def _undefined_message(self) -> str: method _fail_with_undefined_error (line 853) | def _fail_with_undefined_error( method __getattr__ (line 862) | def __getattr__(self, name: str) -> t.Any: method __eq__ (line 883) | def __eq__(self, other: t.Any) -> bool: method __ne__ (line 886) | def __ne__(self, other: t.Any) -> bool: method __hash__ (line 889) | def __hash__(self) -> int: method __str__ (line 892) | def __str__(self) -> str: method __len__ (line 895) | def __len__(self) -> int: method __iter__ (line 898) | def __iter__(self) -> t.Iterator[t.Any]: method __aiter__ (line 901) | async def __aiter__(self) -> t.AsyncIterator[t.Any]: method __bool__ (line 905) | def __bool__(self) -> bool: method __repr__ (line 908) | def __repr__(self) -> str: function make_logging_undefined (line 912) | def make_logging_undefined( class ChainableUndefined (line 970) | class ChainableUndefined(Undefined): method __html__ (line 988) | def __html__(self) -> str: method __getattr__ (line 991) | def __getattr__(self, name: str) -> "ChainableUndefined": method __getitem__ (line 1003) | def __getitem__(self, _name: str) -> "ChainableUndefined": # type: ig... class DebugUndefined (line 1007) | class DebugUndefined(Undefined): method __str__ (line 1023) | def __str__(self) -> str: class StrictUndefined (line 1039) | class StrictUndefined(Undefined): FILE: src/jinja2/sandbox.py function safe_range (line 87) | def safe_range(*args: int) -> range: function unsafe (line 102) | def unsafe(f: F) -> F: function is_internal_attribute (line 115) | def is_internal_attribute(obj: t.Any, attr: str) -> bool: function modifies_known_mutable (line 152) | def modifies_known_mutable(obj: t.Any, attr: str) -> bool: class SandboxedEnvironment (line 177) | class SandboxedEnvironment(Environment): method __init__ (line 242) | def __init__(self, *args: t.Any, **kwargs: t.Any) -> None: method is_safe_attribute (line 248) | def is_safe_attribute(self, obj: t.Any, attr: str, value: t.Any) -> bool: method is_safe_callable (line 257) | def is_safe_callable(self, obj: t.Any) -> bool: method call_binop (line 268) | def call_binop( method call_unop (line 279) | def call_unop(self, context: Context, operator: str, arg: t.Any) -> t.... method getitem (line 288) | def getitem(self, obj: t.Any, argument: str | t.Any) -> t.Any | Undefi... method getattr (line 312) | def getattr(self, obj: t.Any, attribute: str) -> t.Any | Undefined: method unsafe_undefined (line 332) | def unsafe_undefined(self, obj: t.Any, attribute: str) -> Undefined: method wrap_str_format (line 342) | def wrap_str_format(self, value: t.Any) -> t.Callable[..., str] | None: method call (line 386) | def call( class ImmutableSandboxedEnvironment (line 402) | class ImmutableSandboxedEnvironment(SandboxedEnvironment): method is_safe_attribute (line 408) | def is_safe_attribute(self, obj: t.Any, attr: str, value: t.Any) -> bool: class SandboxedFormatter (line 415) | class SandboxedFormatter(Formatter): method __init__ (line 416) | def __init__(self, env: Environment, **kwargs: t.Any) -> None: method get_field (line 420) | def get_field( class SandboxedEscapeFormatter (line 433) | class SandboxedEscapeFormatter(SandboxedFormatter, EscapeFormatter): FILE: src/jinja2/tests.py function test_odd (line 15) | def test_odd(value: int) -> bool: function test_even (line 20) | def test_even(value: int) -> bool: function test_divisibleby (line 25) | def test_divisibleby(value: int, num: int) -> bool: function test_defined (line 30) | def test_defined(value: t.Any) -> bool: function test_undefined (line 47) | def test_undefined(value: t.Any) -> bool: function test_filter (line 53) | def test_filter(env: "Environment", value: str) -> bool: function test_test (line 71) | def test_test(env: "Environment", value: str) -> bool: function test_none (line 92) | def test_none(value: t.Any) -> bool: function test_boolean (line 97) | def test_boolean(value: t.Any) -> bool: function test_false (line 105) | def test_false(value: t.Any) -> bool: function test_true (line 113) | def test_true(value: t.Any) -> bool: function test_integer (line 122) | def test_integer(value: t.Any) -> bool: function test_float (line 131) | def test_float(value: t.Any) -> bool: function test_lower (line 139) | def test_lower(value: str) -> bool: function test_upper (line 144) | def test_upper(value: str) -> bool: function test_string (line 149) | def test_string(value: t.Any) -> bool: function test_mapping (line 154) | def test_mapping(value: t.Any) -> bool: function test_number (line 162) | def test_number(value: t.Any) -> bool: function test_sequence (line 167) | def test_sequence(value: t.Any) -> bool: function test_sameas (line 180) | def test_sameas(value: t.Any, other: t.Any) -> bool: function test_iterable (line 193) | def test_iterable(value: t.Any) -> bool: function test_escaped (line 203) | def test_escaped(value: t.Any) -> bool: function test_in (line 208) | def test_in(value: t.Any, seq: t.Container[t.Any]) -> bool: FILE: src/jinja2/utils.py class _MissingType (line 22) | class _MissingType: method __repr__ (line 23) | def __repr__(self) -> str: method __reduce__ (line 26) | def __reduce__(self) -> str: function pass_context (line 38) | def pass_context(f: F) -> F: function pass_eval_context (line 55) | def pass_eval_context(f: F) -> F: function pass_environment (line 72) | def pass_environment(f: F) -> F: class _PassArg (line 85) | class _PassArg(enum.Enum): method from_obj (line 91) | def from_obj(cls, obj: F) -> t.Optional["_PassArg"]: function internalcode (line 98) | def internalcode(f: F) -> F: function is_undefined (line 104) | def is_undefined(obj: t.Any) -> bool: function consume (line 121) | def consume(iterable: t.Iterable[t.Any]) -> None: function clear_caches (line 127) | def clear_caches() -> None: function import_string (line 140) | def import_string(import_name: str, silent: bool = False) -> t.Any: function open_if_exists (line 164) | def open_if_exists(filename: str, mode: str = "rb") -> t.IO[t.Any] | None: function object_type_repr (line 174) | def object_type_repr(obj: t.Any) -> str: function pformat (line 192) | def pformat(obj: t.Any) -> str: function urlize (line 230) | def urlize( function generate_lorem_ipsum (line 353) | def generate_lorem_ipsum( function url_quote (line 408) | def url_quote(obj: t.Any, charset: str = "utf-8", for_qs: bool = False) ... class LRUCache (line 432) | class LRUCache: method __init__ (line 439) | def __init__(self, capacity: int) -> None: method _postinit (line 445) | def _postinit(self) -> None: method __getstate__ (line 453) | def __getstate__(self) -> t.Mapping[str, t.Any]: method __setstate__ (line 460) | def __setstate__(self, d: t.Mapping[str, t.Any]) -> None: method __getnewargs__ (line 464) | def __getnewargs__(self) -> tuple[t.Any, ...]: method copy (line 467) | def copy(self) -> "te.Self": method get (line 474) | def get(self, key: t.Any, default: t.Any = None) -> t.Any: method setdefault (line 481) | def setdefault(self, key: t.Any, default: t.Any = None) -> t.Any: method clear (line 491) | def clear(self) -> None: method __contains__ (line 497) | def __contains__(self, key: t.Any) -> bool: method __len__ (line 501) | def __len__(self) -> int: method __repr__ (line 505) | def __repr__(self) -> str: method __getitem__ (line 508) | def __getitem__(self, key: t.Any) -> t.Any: method __setitem__ (line 530) | def __setitem__(self, key: t.Any, value: t.Any) -> None: method __delitem__ (line 543) | def __delitem__(self, key: t.Any) -> None: method items (line 555) | def items(self) -> t.Iterable[tuple[t.Any, t.Any]]: method values (line 561) | def values(self) -> t.Iterable[t.Any]: method keys (line 565) | def keys(self) -> t.Iterable[t.Any]: method __iter__ (line 569) | def __iter__(self) -> t.Iterator[t.Any]: method __reversed__ (line 572) | def __reversed__(self) -> t.Iterator[t.Any]: function select_autoescape (line 581) | def select_autoescape( function htmlsafe_json_dumps (line 637) | def htmlsafe_json_dumps( class Cycler (line 677) | class Cycler: method __init__ (line 703) | def __init__(self, *items: t.Any) -> None: method reset (line 709) | def reset(self) -> None: method current (line 714) | def current(self) -> t.Any: method next (line 720) | def next(self) -> t.Any: class Joiner (line 731) | class Joiner: method __init__ (line 734) | def __init__(self, sep: str = ", ") -> None: method __call__ (line 738) | def __call__(self) -> str: class Namespace (line 745) | class Namespace: method __init__ (line 749) | def __init__(*args: t.Any, **kwargs: t.Any) -> None: # noqa: B902 method __getattribute__ (line 753) | def __getattribute__(self, name: str) -> t.Any: method __setitem__ (line 762) | def __setitem__(self, name: str, value: t.Any) -> None: method __repr__ (line 765) | def __repr__(self) -> str: FILE: src/jinja2/visitor.py class VisitCallable (line 12) | class VisitCallable(te.Protocol): method __call__ (line 13) | def __call__(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any... class NodeVisitor (line 16) | class NodeVisitor: method get_visitor (line 28) | def get_visitor(self, node: Node) -> "VisitCallable | None": method visit (line 35) | def visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any: method generic_visit (line 44) | def generic_visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> ... class NodeTransformer (line 50) | class NodeTransformer(NodeVisitor): method generic_visit (line 61) | def generic_visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> ... method visit_list (line 83) | def visit_list(self, node: Node, *args: t.Any, **kwargs: t.Any) -> lis... FILE: tests/conftest.py function _asyncio_run (line 11) | def _asyncio_run(async_fn, *args): function run_async_fn (line 16) | def run_async_fn(request): function env (line 21) | def env(): function dict_loader (line 27) | def dict_loader(): function package_loader (line 33) | def package_loader(): function filesystem_loader (line 39) | def filesystem_loader(): function function_loader (line 46) | def function_loader(): function choice_loader (line 52) | def choice_loader(dict_loader, package_loader): function prefix_loader (line 58) | def prefix_loader(filesystem_loader, dict_loader): FILE: tests/test_api.py class TestExtendedAPI (line 27) | class TestExtendedAPI: method test_item_and_attribute (line 28) | def test_item_and_attribute(self, env): method test_finalize (line 39) | def test_finalize(self): method test_finalize_constant_expression (line 44) | def test_finalize_constant_expression(self): method test_no_finalize_template_data (line 49) | def test_no_finalize_template_data(self): method test_context_finalize (line 55) | def test_context_finalize(self): method test_eval_finalize (line 64) | def test_eval_finalize(self): method test_env_autoescape (line 73) | def test_env_autoescape(self): method test_cycler (line 84) | def test_cycler(self, env): method test_expressions (line 95) | def test_expressions(self, env): method test_template_passthrough (line 105) | def test_template_passthrough(self, env): method test_get_template_undefined (line 112) | def test_get_template_undefined(self, env): method test_autoescape_autoselect (line 135) | def test_autoescape_autoselect(self, env): method test_sandbox_max_range (line 152) | def test_sandbox_max_range(self, env): class TestMeta (line 163) | class TestMeta: method test_find_undeclared_variables (line 164) | def test_find_undeclared_variables(self, env): method test_find_refererenced_templates (line 182) | def test_find_refererenced_templates(self, env): method test_find_included_templates (line 198) | def test_find_included_templates(self, env): class TestStreaming (line 216) | class TestStreaming: method test_basic_streaming (line 217) | def test_basic_streaming(self, env): method test_buffered_streaming (line 226) | def test_buffered_streaming(self, env): method test_streaming_behavior (line 236) | def test_streaming_behavior(self, env): method test_dump_stream (line 245) | def test_dump_stream(self, env): class TestUndefined (line 256) | class TestUndefined: method test_stopiteration_is_undefined (line 257) | def test_stopiteration_is_undefined(self): method test_undefined_and_special_attributes (line 266) | def test_undefined_and_special_attributes(self): method test_undefined_attribute_error (line 270) | def test_undefined_attribute_error(self): method test_logging_undefined (line 285) | def test_logging_undefined(self): method test_default_undefined (line 311) | def test_default_undefined(self): method test_chainable_undefined (line 327) | def test_chainable_undefined(self): method test_debug_undefined (line 351) | def test_debug_undefined(self): method test_strict_undefined (line 368) | def test_strict_undefined(self): method test_indexing_gives_undefined (line 385) | def test_indexing_gives_undefined(self): method test_none_gives_proper_error (line 389) | def test_none_gives_proper_error(self): method test_object_repr (line 393) | def test_object_repr(self): class TestLowLevel (line 400) | class TestLowLevel: method test_custom_code_generator (line 401) | def test_custom_code_generator(self): method test_custom_context (line 417) | def test_custom_context(self): function test_overlay_enable_async (line 430) | def test_overlay_enable_async(env): FILE: tests/test_async.py function test_basic_async (line 14) | def test_basic_async(run_async_fn): function test_await_on_calls (line 26) | def test_await_on_calls(run_async_fn): function test_await_on_calls_normal_render (line 42) | def test_await_on_calls_normal_render(): function test_await_and_macros (line 55) | def test_await_and_macros(run_async_fn): function test_async_blocks (line 71) | def test_async_blocks(run_async_fn): function test_async_generate (line 85) | def test_async_generate(): function test_async_iteration_in_templates (line 91) | def test_async_iteration_in_templates(): function test_async_iteration_in_templates_extended (line 102) | def test_async_iteration_in_templates_extended(): function test_env_async (line 112) | def test_env_async(): class TestAsyncImports (line 127) | class TestAsyncImports: method test_context_imports (line 128) | def test_context_imports(self, test_env_async): method test_trailing_comma (line 150) | def test_trailing_comma(self, test_env_async): method test_exports (line 157) | def test_exports(self, test_env_async, run_async_fn): method test_import_with_globals (line 174) | def test_import_with_globals(self, test_env_async): method test_import_with_globals_override (line 183) | def test_import_with_globals_override(self, test_env_async): method test_from_import_with_globals (line 190) | def test_from_import_with_globals(self, test_env_async): class TestAsyncIncludes (line 198) | class TestAsyncIncludes: method test_context_include (line 199) | def test_context_include(self, test_env_async): method test_choice_includes (line 207) | def test_choice_includes(self, test_env_async): method test_include_ignoring_missing (line 241) | def test_include_ignoring_missing(self, test_env_async): method test_context_include_with_overrides (line 250) | def test_context_include_with_overrides(self, test_env_async): method test_unoptimized_scopes (line 261) | def test_unoptimized_scopes(self, test_env_async): method test_unoptimized_scopes_autoescape (line 275) | def test_unoptimized_scopes_autoescape(self): class TestAsyncForLoop (line 295) | class TestAsyncForLoop: method test_simple (line 296) | def test_simple(self, test_env_async): method test_else (line 300) | def test_else(self, test_env_async): method test_empty_blocks (line 306) | def test_empty_blocks(self, test_env_async): method test_context_vars (line 315) | def test_context_vars(self, test_env_async, transform): method test_cycling (line 324) | def test_cycling(self, test_env_async): method test_lookaround (line 333) | def test_lookaround(self, test_env_async): method test_changed (line 343) | def test_changed(self, test_env_async): method test_scope (line 352) | def test_scope(self, test_env_async): method test_varlen (line 357) | def test_varlen(self, test_env_async): method test_noniter (line 367) | def test_noniter(self, test_env_async): method test_recursive (line 371) | def test_recursive(self, test_env_async): method test_recursive_lookaround (line 388) | def test_recursive_lookaround(self, test_env_async): method test_recursive_depth0 (line 407) | def test_recursive_depth0(self, test_env_async): method test_recursive_depth (line 423) | def test_recursive_depth(self, test_env_async): method test_looploop (line 439) | def test_looploop(self, test_env_async): method test_reversed_bug (line 450) | def test_reversed_bug(self, test_env_async): method test_loop_errors (line 456) | def test_loop_errors(self, test_env_async, run_async_fn): method test_loop_filter (line 470) | def test_loop_filter(self, test_env_async): method test_scoped_special_var (line 482) | def test_scoped_special_var(self, test_env_async): method test_scoped_loop_var (line 489) | def test_scoped_loop_var(self, test_env_async): method test_recursive_empty_loop_iter (line 501) | def test_recursive_empty_loop_iter(self, test_env_async): method test_call_in_loop (line 509) | def test_call_in_loop(self, test_env_async): method test_scoping_bug (line 525) | def test_scoping_bug(self, test_env_async): method test_unpacking (line 535) | def test_unpacking(self, test_env_async): method test_recursive_loop_filter (line 541) | def test_recursive_loop_filter(self, test_env_async): method test_nonrecursive_loop_filter (line 566) | def test_nonrecursive_loop_filter(self, test_env_async): method test_bare_async (line 589) | def test_bare_async(self, test_env_async): method test_awaitable_property_slicing (line 593) | def test_awaitable_property_slicing(self, test_env_async): function test_namespace_awaitable (line 598) | def test_namespace_awaitable(test_env_async, run_async_fn): function test_chainable_undefined_aiter (line 609) | def test_chainable_undefined_aiter(run_async_fn): function async_native_env (line 623) | def async_native_env(): function test_native_async (line 627) | def test_native_async(async_native_env, run_async_fn): function test_native_list_async (line 636) | def test_native_list_async(async_native_env, run_async_fn): function test_getitem_after_filter (line 645) | def test_getitem_after_filter(): function test_getitem_after_call (line 653) | def test_getitem_after_call(): function test_basic_generate_async (line 661) | def test_basic_generate_async(run_async_fn): function test_include_generate_async (line 677) | def test_include_generate_async(run_async_fn, test_env_async): function test_blocks_generate_async (line 691) | def test_blocks_generate_async(run_async_fn): function test_async_extend (line 709) | def test_async_extend(run_async_fn, test_env_async): FILE: tests/test_async_filters.py function make_aiter (line 11) | async def make_aiter(iter): function mark_dualiter (line 16) | def mark_dualiter(parameter, factory): function env_async (line 26) | def env_async(): function closing_factory (line 31) | async def closing_factory(): function test_first (line 47) | def test_first(env_async, foo, run_async_fn): function test_groupby (line 66) | def test_groupby(env_async, items): function test_groupby_case (line 88) | def test_groupby_case(env_async, case_sensitive, expect): function test_groupby_tuple_index (line 102) | def test_groupby_tuple_index(env_async, items): function make_articles (line 112) | def make_articles(): function test_groupby_multidot (line 124) | def test_groupby_multidot(env_async, articles): function test_join_env_int (line 139) | def test_join_env_int(env_async, int_items): function test_join_string_list (line 146) | def test_join_string_list(string_items): function make_users (line 152) | def make_users(): function test_join_attribute (line 158) | def test_join_attribute(env_async, users): function test_simple_reject (line 164) | def test_simple_reject(env_async, items): function test_bool_reject (line 170) | def test_bool_reject(env_async, items): function test_simple_select (line 176) | def test_simple_select(env_async, items): function test_bool_select (line 182) | def test_bool_select(env_async, items): function make_users (line 187) | def make_users(): # type: ignore function test_simple_select_attr (line 197) | def test_simple_select_attr(env_async, users): function test_simple_map (line 205) | def test_simple_map(env_async, items): function test_map_sum (line 210) | def test_map_sum(env_async): # async map + async filter function test_attribute_map (line 216) | def test_attribute_map(env_async, users): function test_empty_map (line 221) | def test_empty_map(env_async): function test_sum (line 227) | def test_sum(env_async, items): function test_sum_attributes (line 233) | def test_sum_attributes(env_async, items): function test_sum_attributes_nested (line 238) | def test_sum_attributes_nested(env_async): function test_sum_attributes_tuple (line 252) | def test_sum_attributes_tuple(env_async): function test_slice (line 258) | def test_slice(env_async, items): function test_unique_with_async_gen (line 269) | def test_unique_with_async_gen(env_async): function test_custom_async_filter (line 276) | def test_custom_async_filter(env_async, run_async_fn): function test_custom_async_iteratable_filter (line 292) | def test_custom_async_iteratable_filter(env_async, items, run_async_fn): FILE: tests/test_bytecode_cache.py function env (line 11) | def env(package_loader, tmp_path): class TestByteCodeCache (line 16) | class TestByteCodeCache: method test_simple (line 17) | def test_simple(self, env): class MockMemcached (line 23) | class MockMemcached: class Error (line 24) | class Error(Exception): method get (line 31) | def get(self, key): method set (line 34) | def set(self, key, value, timeout=None): method get_side_effect (line 39) | def get_side_effect(self, key): method set_side_effect (line 42) | def set_side_effect(self, *args): class TestMemcachedBytecodeCache (line 46) | class TestMemcachedBytecodeCache: method test_dump_load (line 47) | def test_dump_load(self): method test_exception (line 60) | def test_exception(self): FILE: tests/test_compile.py function test_filters_deterministic (line 11) | def test_filters_deterministic(tmp_path): function test_import_as_with_context_deterministic (line 23) | def test_import_as_with_context_deterministic(tmp_path): function test_top_level_set_vars_unpacking_deterministic (line 34) | def test_top_level_set_vars_unpacking_deterministic(tmp_path): function test_loop_set_vars_unpacking_deterministic (line 59) | def test_loop_set_vars_unpacking_deterministic(tmp_path): function test_block_set_vars_unpacking_deterministic (line 77) | def test_block_set_vars_unpacking_deterministic(tmp_path): function test_undefined_import_curly_name (line 95) | def test_undefined_import_curly_name(): FILE: tests/test_core_tags.py function env_trim (line 11) | def env_trim(): class TestForLoop (line 15) | class TestForLoop: method test_simple (line 16) | def test_simple(self, env): method test_else (line 20) | def test_else(self, env): method test_else_scoping_item (line 24) | def test_else_scoping_item(self, env): method test_empty_blocks (line 28) | def test_empty_blocks(self, env): method test_context_vars (line 32) | def test_context_vars(self, env): method test_cycling (line 69) | def test_cycling(self, env): method test_lookaround (line 78) | def test_lookaround(self, env): method test_changed (line 88) | def test_changed(self, env): method test_scope (line 97) | def test_scope(self, env): method test_varlen (line 102) | def test_varlen(self, env): method test_noniter (line 107) | def test_noniter(self, env): method test_recursive (line 111) | def test_recursive(self, env): method test_recursive_lookaround (line 128) | def test_recursive_lookaround(self, env): method test_recursive_depth0 (line 147) | def test_recursive_depth0(self, env): method test_recursive_depth (line 164) | def test_recursive_depth(self, env): method test_looploop (line 181) | def test_looploop(self, env): method test_reversed_bug (line 192) | def test_reversed_bug(self, env): method test_loop_errors (line 198) | def test_loop_errors(self, env): method test_loop_filter (line 210) | def test_loop_filter(self, env): method test_loop_unassignable (line 222) | def test_loop_unassignable(self, env): method test_scoped_special_var (line 227) | def test_scoped_special_var(self, env): method test_scoped_loop_var (line 234) | def test_scoped_loop_var(self, env): method test_recursive_empty_loop_iter (line 246) | def test_recursive_empty_loop_iter(self, env): method test_call_in_loop (line 254) | def test_call_in_loop(self, env): method test_scoping_bug (line 270) | def test_scoping_bug(self, env): method test_unpacking (line 280) | def test_unpacking(self, env): method test_intended_scoping_with_set (line 286) | def test_intended_scoping_with_set(self, env): class TestIfCondition (line 299) | class TestIfCondition: method test_simple (line 300) | def test_simple(self, env): method test_elif (line 304) | def test_elif(self, env): method test_elif_deep (line 311) | def test_elif_deep(self, env): method test_else (line 318) | def test_else(self, env): method test_empty (line 322) | def test_empty(self, env): method test_complete (line 326) | def test_complete(self, env): method test_no_scope (line 332) | def test_no_scope(self, env): class TestMacros (line 339) | class TestMacros: method test_simple (line 340) | def test_simple(self, env_trim): method test_scoping (line 348) | def test_scoping(self, env_trim): method test_arguments (line 358) | def test_arguments(self, env_trim): method test_arguments_defaults_nonsense (line 366) | def test_arguments_defaults_nonsense(self, env_trim): method test_caller_defaults_nonsense (line 374) | def test_caller_defaults_nonsense(self, env_trim): method test_varargs (line 383) | def test_varargs(self, env_trim): method test_simple_call (line 391) | def test_simple_call(self, env_trim): method test_complex_call (line 399) | def test_complex_call(self, env_trim): method test_caller_undefined (line 407) | def test_caller_undefined(self, env_trim): method test_include (line 416) | def test_include(self, env_trim): method test_macro_api (line 425) | def test_macro_api(self, env_trim): method test_callself (line 442) | def test_callself(self, env_trim): method test_macro_defaults_self_ref (line 450) | def test_macro_defaults_self_ref(self, env): class TestSet (line 463) | class TestSet: method test_normal (line 464) | def test_normal(self, env_trim): method test_block (line 469) | def test_block(self, env_trim): method test_block_escaping (line 474) | def test_block_escaping(self): method test_set_invalid (line 481) | def test_set_invalid(self, env_trim): method test_namespace_redefined (line 489) | def test_namespace_redefined(self, env_trim): method test_namespace (line 494) | def test_namespace(self, env_trim): method test_namespace_block (line 500) | def test_namespace_block(self, env_trim): method test_init_namespace (line 506) | def test_init_namespace(self, env_trim): method test_namespace_loop (line 514) | def test_namespace_loop(self, env_trim): method test_namespace_macro (line 527) | def test_namespace_macro(self, env_trim): method test_namespace_set_tuple (line 539) | def test_namespace_set_tuple(self, env_trim): method test_block_escaping_filtered (line 547) | def test_block_escaping_filtered(self): method test_block_filtered (line 554) | def test_block_filtered(self, env_trim): method test_block_filtered_set (line 561) | def test_block_filtered_set(self, env_trim): class TestWith (line 578) | class TestWith: method test_with (line 579) | def test_with(self, env): method test_with_argument_scoping (line 593) | def test_with_argument_scoping(self, env): FILE: tests/test_debug.py function fs_env (line 14) | def fs_env(filesystem_loader): class TestDebug (line 19) | class TestDebug: method assert_traceback_matches (line 20) | def assert_traceback_matches(self, callback, expected_tb): method test_runtime_error (line 30) | def test_runtime_error(self, fs_env): method test_syntax_error (line 48) | def test_syntax_error(self, fs_env): method test_regular_syntax_error (line 63) | def test_regular_syntax_error(self, fs_env): method test_pickleable_syntax_error (line 77) | def test_pickleable_syntax_error(self, fs_env): method test_include_syntax_error_source (line 83) | def test_include_syntax_error_source(self, filesystem_loader): method test_local_extraction (line 99) | def test_local_extraction(self): method test_get_corresponding_lineno_traceback (line 115) | def test_get_corresponding_lineno_traceback(self, fs_env): FILE: tests/test_ext.py function _get_with_context (line 74) | def _get_with_context(value, ctx=None): function gettext (line 82) | def gettext(context, string): function ngettext (line 89) | def ngettext(context, s, p, n): function pgettext (line 101) | def pgettext(context, c, s): function npgettext (line 108) | def npgettext(context, c, s, p, n): class ExampleExtension (line 152) | class ExampleExtension(Extension): method parse (line 157) | def parse(self, parser): method _dump (line 172) | def _dump(self, sandboxed, ext_attr, imported_object, context): class DerivedExampleExtension (line 179) | class DerivedExampleExtension(ExampleExtension): class PreprocessorExtension (line 183) | class PreprocessorExtension(Extension): method preprocess (line 184) | def preprocess(self, source, name, filename=None): class StreamFilterExtension (line 188) | class StreamFilterExtension(Extension): method filter_stream (line 189) | def filter_stream(self, stream): method interpolate (line 196) | def interpolate(self, token): class TestExtensions (line 219) | class TestExtensions: method test_extend_late (line 220) | def test_extend_late(self): method test_loop_controls (line 225) | def test_loop_controls(self): method test_do (line 246) | def test_do(self): method test_extension_nodes (line 257) | def test_extension_nodes(self): method test_contextreference_node_passes_context (line 262) | def test_contextreference_node_passes_context(self): method test_contextreference_node_can_pass_locals (line 267) | def test_contextreference_node_can_pass_locals(self): method test_identifier (line 274) | def test_identifier(self): method test_rebinding (line 277) | def test_rebinding(self): method test_preprocessor_extension (line 284) | def test_preprocessor_extension(self): method test_streamfilter_extension (line 289) | def test_streamfilter_extension(self): method test_extension_ordering (line 296) | def test_extension_ordering(self): method test_debug (line 308) | def test_debug(self): class TestInternationalization (line 317) | class TestInternationalization: method test_trans (line 318) | def test_trans(self): method test_trans_plural (line 322) | def test_trans_plural(self): method test_trans_plural_with_functions (line 327) | def test_trans_plural_with_functions(self): method test_complex_plural (line 338) | def test_complex_plural(self): method test_trans_stringformatting (line 350) | def test_trans_stringformatting(self): method test_trimmed (line 354) | def test_trimmed(self): method test_trimmed_policy (line 360) | def test_trimmed_policy(self): method test_trimmed_policy_override (line 367) | def test_trimmed_policy_override(self): method test_trimmed_vars (line 373) | def test_trimmed_vars(self): method test_trimmed_varname_trimmed (line 379) | def test_trimmed_varname_trimmed(self): method test_extract (line 387) | def test_extract(self): method test_extract_trimmed (line 403) | def test_extract_trimmed(self): method test_extract_trimmed_option (line 420) | def test_extract_trimmed_option(self): method test_comment_extract (line 438) | def test_comment_extract(self): method test_extract_context (line 458) | def test_extract_context(self): method test_nested_trans_error (line 472) | def test_nested_trans_error(self): method test_trans_block_error (line 478) | def test_trans_block_error(self): class TestScope (line 485) | class TestScope: method test_basic_scope_behavior (line 486) | def test_basic_scope_behavior(self): class TestNewstyleInternationalization (line 518) | class TestNewstyleInternationalization: method test_trans (line 519) | def test_trans(self): method test_trans_plural (line 523) | def test_trans_plural(self): method test_complex_plural (line 528) | def test_complex_plural(self): method test_trans_stringformatting (line 540) | def test_trans_stringformatting(self): method test_newstyle_plural (line 544) | def test_newstyle_plural(self): method test_autoescape_support (line 549) | def test_autoescape_support(self): method test_autoescape_macros (line 562) | def test_autoescape_macros(self): method test_num_used_twice (line 570) | def test_num_used_twice(self): method test_num_called_num (line 574) | def test_num_called_num(self): method test_trans_vars (line 591) | def test_trans_vars(self): method test_novars_vars_escaping (line 599) | def test_novars_vars_escaping(self): method test_context (line 607) | def test_context(self): method test_context_plural (line 611) | def test_context_plural(self): method test_context_block (line 616) | def test_context_block(self): method test_context_plural_block (line 620) | def test_context_plural_block(self): class TestAutoEscape (line 626) | class TestAutoEscape: method test_scoped_setting (line 627) | def test_scoped_setting(self): method test_nonvolatile (line 660) | def test_nonvolatile(self): method test_volatile (line 670) | def test_volatile(self): method test_scoping (line 679) | def test_scoping(self): method test_volatile_scoping (line 687) | def test_volatile_scoping(self): method test_overlay_scopes (line 712) | def test_overlay_scopes(self): FILE: tests/test_filters.py class Magic (line 14) | class Magic: method __init__ (line 15) | def __init__(self, value): method __str__ (line 18) | def __str__(self): class Magic2 (line 22) | class Magic2: method __init__ (line 23) | def __init__(self, value1, value2): method __str__ (line 27) | def __str__(self): class TestFilter (line 31) | class TestFilter: method test_filter_calling (line 32) | def test_filter_calling(self, env): method test_capitalize (line 36) | def test_capitalize(self, env): method test_center (line 40) | def test_center(self, env): method test_default (line 44) | def test_default(self, env): method test_dictsort (line 60) | def test_dictsort(self, env, args, expect): method test_batch (line 65) | def test_batch(self, env): method test_slice (line 73) | def test_slice(self, env): method test_escape (line 81) | def test_escape(self, env): method test_trim (line 89) | def test_trim(self, env, chars, expect): method test_striptags (line 94) | def test_striptags(self, env): method test_filesizeformat (line 103) | def test_filesizeformat(self, env): method test_filesizeformat_issue59 (line 122) | def test_filesizeformat_issue59(self, env): method test_first (line 138) | def test_first(self, env): method test_float (line 146) | def test_float(self, env, value, expect): method test_float_default (line 150) | def test_float_default(self, env): method test_format (line 154) | def test_format(self, env): method _test_indent_multiline_template (line 160) | def _test_indent_multiline_template(env, markup=False): method test_indent (line 173) | def test_indent(self, env): method test_indent_markup_input (line 182) | def test_indent_markup_input(self, env): method test_indent_width_string (line 188) | def test_indent_width_string(self, env): method test_int (line 202) | def test_int(self, env, value, expect): method test_int_base (line 210) | def test_int_base(self, env, value, base, expect): method test_int_default (line 214) | def test_int_default(self, env): method test_int_special_method (line 218) | def test_int_special_method(self, env): method test_join (line 226) | def test_join(self, env): method test_join_attribute (line 235) | def test_join_attribute(self, env): method test_last (line 240) | def test_last(self, env): method test_length (line 245) | def test_length(self, env): method test_lower (line 250) | def test_lower(self, env): method test_items (line 255) | def test_items(self, env): method test_items_undefined (line 261) | def test_items_undefined(self, env): method test_pprint (line 266) | def test_pprint(self, env): method test_random (line 273) | def test_random(self, env, request): method test_reverse (line 289) | def test_reverse(self, env): method test_string (line 295) | def test_string(self, env): method test_title (line 300) | def test_title(self, env): method test_truncate (line 332) | def test_truncate(self, env): method test_truncate_very_short (line 341) | def test_truncate_very_short(self, env): method test_truncate_end_length (line 348) | def test_truncate_end_length(self, env): method test_upper (line 353) | def test_upper(self, env): method test_urlize (line 357) | def test_urlize(self, env): method test_urlize_rel_policy (line 376) | def test_urlize_rel_policy(self): method test_urlize_target_parameter (line 384) | def test_urlize_target_parameter(self, env): method test_urlize_extra_schemes_parameter (line 394) | def test_urlize_extra_schemes_parameter(self, env): method test_wordcount (line 405) | def test_wordcount(self, env): method test_block (line 414) | def test_block(self, env): method test_chaining (line 418) | def test_chaining(self, env): method test_sum (line 422) | def test_sum(self, env): method test_sum_attributes (line 426) | def test_sum_attributes(self, env): method test_sum_attributes_nested (line 430) | def test_sum_attributes_nested(self, env): method test_sum_attributes_tuple (line 443) | def test_sum_attributes_tuple(self, env): method test_abs (line 447) | def test_abs(self, env): method test_round_positive (line 451) | def test_round_positive(self, env): method test_round_negative (line 459) | def test_round_negative(self, env): method test_xmlattr (line 467) | def test_xmlattr(self, env): method test_xmlattr_key_invalid (line 479) | def test_xmlattr_key_invalid(self, env: Environment, sep: str) -> None: method test_sort1 (line 485) | def test_sort1(self, env): method test_sort2 (line 489) | def test_sort2(self, env): method test_sort3 (line 493) | def test_sort3(self, env): method test_sort4 (line 497) | def test_sort4(self, env): method test_sort5 (line 501) | def test_sort5(self, env): method test_sort6 (line 505) | def test_sort6(self, env): method test_sort7 (line 516) | def test_sort7(self, env): method test_sort8 (line 527) | def test_sort8(self, env): method test_unique (line 541) | def test_unique(self, env): method test_unique_case_sensitive (line 545) | def test_unique_case_sensitive(self, env): method test_unique_attribute (line 549) | def test_unique_attribute(self, env): method test_min_max (line 564) | def test_min_max(self, env, source, expect): method test_min_max_attribute (line 569) | def test_min_max_attribute(self, env, name, expect): method test_groupby (line 573) | def test_groupby(self, env): method test_groupby_tuple_index (line 585) | def test_groupby_tuple_index(self, env): method test_groupby_multidot (line 594) | def test_groupby_multidot(self, env): method test_groupby_default (line 615) | def test_groupby_default(self, env): method test_groupby_case (line 637) | def test_groupby_case(self, env, case_sensitive, expect): method test_filtertag (line 649) | def test_filtertag(self, env): method test_replace (line 655) | def test_replace(self, env): method test_forceescape (line 667) | def test_forceescape(self, env): method test_safe (line 671) | def test_safe(self, env): method test_urlencode (line 691) | def test_urlencode(self, value, expect): method test_simple_map (line 696) | def test_simple_map(self, env): method test_map_sum (line 701) | def test_map_sum(self, env): method test_attribute_map (line 705) | def test_attribute_map(self, env): method test_empty_map (line 716) | def test_empty_map(self, env): method test_map_default (line 721) | def test_map_default(self, env): method test_simple_select (line 744) | def test_simple_select(self, env): method test_bool_select (line 749) | def test_bool_select(self, env): method test_simple_reject (line 754) | def test_simple_reject(self, env): method test_bool_reject (line 759) | def test_bool_reject(self, env): method test_simple_select_attr (line 764) | def test_simple_select_attr(self, env): method test_simple_reject_attr (line 777) | def test_simple_reject_attr(self, env): method test_func_select_attr (line 790) | def test_func_select_attr(self, env): method test_func_reject_attr (line 803) | def test_func_reject_attr(self, env): method test_json_dump (line 816) | def test_json_dump(self): method test_wordwrap (line 831) | def test_wordwrap(self, env): method test_filter_undefined (line 837) | def test_filter_undefined(self, env): method test_filter_undefined_in_if (line 841) | def test_filter_undefined_in_if(self, env): method test_filter_undefined_in_elif (line 847) | def test_filter_undefined_in_elif(self, env): method test_filter_undefined_in_else (line 856) | def test_filter_undefined_in_else(self, env): method test_filter_undefined_in_nested_if (line 864) | def test_filter_undefined_in_nested_if(self, env): method test_filter_undefined_in_condexpr (line 874) | def test_filter_undefined_in_condexpr(self, env): FILE: tests/test_idtracking.py function test_basics (line 5) | def test_basics(): function test_complex (line 39) | def test_complex(): function test_if_branching_stores (line 212) | def test_if_branching_stores(): function test_if_branching_stores_undefined (line 236) | def test_if_branching_stores_undefined(): function test_if_branching_multi_scope (line 261) | def test_if_branching_multi_scope(): FILE: tests/test_imports.py function test_env (line 12) | def test_env(): class TestImports (line 26) | class TestImports: method test_context_imports (line 27) | def test_context_imports(self, test_env): method test_import_needs_name (line 49) | def test_import_needs_name(self, test_env): method test_no_trailing_comma (line 56) | def test_no_trailing_comma(self, test_env): method test_trailing_comma_with_context (line 66) | def test_trailing_comma_with_context(self, test_env): method test_exports (line 79) | def test_exports(self, test_env): method test_not_exported (line 95) | def test_not_exported(self, test_env): method test_import_with_globals (line 101) | def test_import_with_globals(self, test_env): method test_import_with_globals_override (line 110) | def test_import_with_globals_override(self, test_env): method test_from_import_with_globals (line 117) | def test_from_import_with_globals(self, test_env): class TestIncludes (line 125) | class TestIncludes: method test_context_include (line 126) | def test_context_include(self, test_env): method test_choice_includes (line 134) | def test_choice_includes(self, test_env): method test_include_ignoring_missing (line 164) | def test_include_ignoring_missing(self, test_env): method test_context_include_with_overrides (line 173) | def test_context_include_with_overrides(self, test_env): method test_unoptimized_scopes (line 184) | def test_unoptimized_scopes(self, test_env): method test_import_from_with_context (line 198) | def test_import_from_with_context(self): FILE: tests/test_inheritance.py function env (line 60) | def env(): class TestInheritance (line 77) | class TestInheritance: method test_layout (line 78) | def test_layout(self, env): method test_level1 (line 84) | def test_level1(self, env): method test_level2 (line 90) | def test_level2(self, env): method test_level3 (line 97) | def test_level3(self, env): method test_level4 (line 103) | def test_level4(self, env): method test_super (line 109) | def test_super(self, env): method test_working (line 126) | def test_working(self, env): method test_reuse_blocks (line 129) | def test_reuse_blocks(self, env): method test_preserve_blocks (line 135) | def test_preserve_blocks(self, env): method test_dynamic_inheritance (line 148) | def test_dynamic_inheritance(self, env): method test_multi_inheritance (line 162) | def test_multi_inheritance(self, env): method test_scoped_block (line 181) | def test_scoped_block(self, env): method test_super_in_scoped_block (line 195) | def test_super_in_scoped_block(self, env): method test_scoped_block_after_inheritance (line 210) | def test_scoped_block_after_inheritance(self, env): method test_level1_required (line 237) | def test_level1_required(self, env): method test_level2_required (line 249) | def test_level2_required(self, env): method test_level3_required (line 265) | def test_level3_required(self, env): method test_invalid_required (line 286) | def test_invalid_required(self, env): method test_required_with_scope (line 319) | def test_required_with_scope(self, env): method test_duplicate_required_or_scoped (line 343) | def test_duplicate_required_or_scoped(self, env): class TestBugFix (line 366) | class TestBugFix: method test_fixed_macro_scoping_bug (line 367) | def test_fixed_macro_scoping_bug(self, env): method test_double_extends (line 405) | def test_double_extends(self, env): FILE: tests/test_lexnparse.py class TestTokenStream (line 15) | class TestTokenStream: method test_simple (line 21) | def test_simple(self, env): method test_iter (line 35) | def test_iter(self, env): class TestLexer (line 43) | class TestLexer: method test_raw1 (line 44) | def test_raw1(self, env): method test_raw2 (line 50) | def test_raw2(self, env): method test_raw3 (line 54) | def test_raw3(self, env): method test_raw4 (line 61) | def test_raw4(self, env): method test_balancing (line 70) | def test_balancing(self, env): method test_comments (line 78) | def test_comments(self, env): method test_string_escapes (line 92) | def test_string_escapes(self, env): method test_bytefallback (line 98) | def test_bytefallback(self, env): method test_operators (line 104) | def test_operators(self, env): method test_normalizing (line 114) | def test_normalizing(self, env): method test_trailing_newline (line 121) | def test_trailing_newline(self, env): method test_name (line 156) | def test_name(self, env, name, valid): method test_lineno_with_strip (line 165) | def test_lineno_with_strip(self, env): class TestParser (line 184) | class TestParser: method test_php_syntax (line 185) | def test_php_syntax(self, env): method test_erb_syntax (line 196) | def test_erb_syntax(self, env): method test_comment_syntax (line 207) | def test_comment_syntax(self, env): method test_balancing (line 218) | def test_balancing(self, env): method test_start_comment (line 222) | def test_start_comment(self, env): method test_line_syntax (line 231) | def test_line_syntax(self, env): method test_line_syntax_priority (line 256) | def test_line_syntax_priority(self, env): method test_error_messages (line 280) | def test_error_messages(self, env): class TestSyntax (line 317) | class TestSyntax: method test_call (line 318) | def test_call(self, env): method test_slicing (line 324) | def test_slicing(self, env): method test_attr (line 328) | def test_attr(self, env): method test_subscript (line 332) | def test_subscript(self, env): method test_tuple (line 336) | def test_tuple(self, env): method test_math (line 340) | def test_math(self, env): method test_div (line 344) | def test_div(self, env): method test_unary (line 348) | def test_unary(self, env): method test_concat (line 352) | def test_concat(self, env): method test_compare (line 367) | def test_compare(self, env, a, op, b): method test_compare_parens (line 371) | def test_compare_parens(self, env): method test_compare_compound (line 386) | def test_compare_compound(self, env, src, expect): method test_inop (line 390) | def test_inop(self, env): method test_collection_literal (line 395) | def test_collection_literal(self, env, value): method test_numeric_literal (line 423) | def test_numeric_literal(self, env, value, expect): method test_bool (line 427) | def test_bool(self, env): method test_grouping (line 433) | def test_grouping(self, env): method test_django_attr (line 439) | def test_django_attr(self, env): method test_conditional_expression (line 443) | def test_conditional_expression(self, env): method test_short_conditional_expression (line 447) | def test_short_conditional_expression(self, env): method test_filter_priority (line 454) | def test_filter_priority(self, env): method test_function_calls (line 458) | def test_function_calls(self, env): method test_tuple_expr (line 483) | def test_tuple_expr(self, env): method test_trailing_comma (line 496) | def test_trailing_comma(self, env): method test_block_end_name (line 500) | def test_block_end_name(self, env): method test_constant_casing (line 506) | def test_constant_casing(self, env): method test_test_chaining (line 514) | def test_test_chaining(self, env): method test_string_concatenation (line 520) | def test_string_concatenation(self, env): method test_notin (line 524) | def test_notin(self, env): method test_operator_precedence (line 529) | def test_operator_precedence(self, env): method test_implicit_subscribed_tuple (line 533) | def test_implicit_subscribed_tuple(self, env): method test_raw2 (line 541) | def test_raw2(self, env): method test_const (line 545) | def test_const(self, env): method test_neg_filter_priority (line 552) | def test_neg_filter_priority(self, env): method test_const_assign (line 557) | def test_const_assign(self, env): method test_localset (line 563) | def test_localset(self, env): method test_parse_unary (line 571) | def test_parse_unary(self, env): class TestLstripBlocks (line 578) | class TestLstripBlocks: method test_lstrip (line 579) | def test_lstrip(self, env): method test_lstrip_trim (line 584) | def test_lstrip_trim(self, env): method test_no_lstrip (line 589) | def test_no_lstrip(self, env): method test_lstrip_blocks_false_with_no_lstrip (line 594) | def test_lstrip_blocks_false_with_no_lstrip(self, env): method test_lstrip_endline (line 602) | def test_lstrip_endline(self, env): method test_lstrip_inline (line 607) | def test_lstrip_inline(self, env): method test_lstrip_nested (line 612) | def test_lstrip_nested(self, env): method test_lstrip_left_chars (line 619) | def test_lstrip_left_chars(self, env): method test_lstrip_embeded_strings (line 627) | def test_lstrip_embeded_strings(self, env): method test_lstrip_preserve_leading_newlines (line 632) | def test_lstrip_preserve_leading_newlines(self, env): method test_lstrip_comment (line 637) | def test_lstrip_comment(self, env): method test_lstrip_angle_bracket_simple (line 646) | def test_lstrip_angle_bracket_simple(self, env): method test_lstrip_angle_bracket_comment (line 662) | def test_lstrip_angle_bracket_comment(self, env): method test_lstrip_angle_bracket (line 678) | def test_lstrip_angle_bracket(self, env): method test_lstrip_angle_bracket_compact (line 700) | def test_lstrip_angle_bracket_compact(self, env): method test_lstrip_blocks_outside_with_new_line (line 722) | def test_lstrip_blocks_outside_with_new_line(self): method test_lstrip_trim_blocks_outside_with_new_line (line 732) | def test_lstrip_trim_blocks_outside_with_new_line(self): method test_lstrip_blocks_inside_with_new_line (line 742) | def test_lstrip_blocks_inside_with_new_line(self): method test_lstrip_trim_blocks_inside_with_new_line (line 752) | def test_lstrip_trim_blocks_inside_with_new_line(self): method test_lstrip_blocks_without_new_line (line 762) | def test_lstrip_blocks_without_new_line(self): method test_lstrip_trim_blocks_without_new_line (line 772) | def test_lstrip_trim_blocks_without_new_line(self): method test_lstrip_blocks_consume_after_without_new_line (line 782) | def test_lstrip_blocks_consume_after_without_new_line(self): method test_lstrip_trim_blocks_consume_before_without_new_line (line 792) | def test_lstrip_trim_blocks_consume_before_without_new_line(self): method test_lstrip_trim_blocks_comment (line 802) | def test_lstrip_trim_blocks_comment(self): method test_lstrip_trim_blocks_raw (line 808) | def test_lstrip_trim_blocks_raw(self): method test_php_syntax_with_manual (line 814) | def test_php_syntax_with_manual(self, env): method test_php_syntax (line 827) | def test_php_syntax(self, env): method test_php_syntax_compact (line 840) | def test_php_syntax_compact(self, env): method test_erb_syntax (line 853) | def test_erb_syntax(self, env): method test_erb_syntax_with_manual (line 867) | def test_erb_syntax_with_manual(self, env): method test_erb_syntax_no_lstrip (line 880) | def test_erb_syntax_no_lstrip(self, env): method test_comment_syntax (line 893) | def test_comment_syntax(self, env): class TestTrimBlocks (line 914) | class TestTrimBlocks: method test_trim (line 915) | def test_trim(self, env): method test_no_trim (line 920) | def test_no_trim(self, env): method test_no_trim_outer (line 925) | def test_no_trim_outer(self, env): method test_lstrip_no_trim (line 930) | def test_lstrip_no_trim(self, env): method test_trim_blocks_false_with_no_trim (line 935) | def test_trim_blocks_false_with_no_trim(self, env): method test_trim_nested (line 953) | def test_trim_nested(self, env): method test_no_trim_nested (line 960) | def test_no_trim_nested(self, env): method test_comment_trim (line 967) | def test_comment_trim(self, env): method test_comment_no_trim (line 972) | def test_comment_no_trim(self, env): method test_multiple_comment_trim_lstrip (line 977) | def test_multiple_comment_trim_lstrip(self, env): method test_multiple_comment_no_trim_lstrip (line 984) | def test_multiple_comment_no_trim_lstrip(self, env): method test_raw_trim_lstrip (line 991) | def test_raw_trim_lstrip(self, env): method test_raw_no_trim_lstrip (line 996) | def test_raw_no_trim_lstrip(self, env): method test_no_trim_angle_bracket (line 1005) | def test_no_trim_angle_bracket(self, env): method test_no_trim_php_syntax (line 1015) | def test_no_trim_php_syntax(self, env): FILE: tests/test_loader.py class TestLoaders (line 21) | class TestLoaders: method test_dict_loader (line 22) | def test_dict_loader(self, dict_loader): method test_package_loader (line 28) | def test_package_loader(self, package_loader): method test_filesystem_loader_overlapping_names (line 34) | def test_filesystem_loader_overlapping_names(self, filesystem_loader): method test_choice_loader (line 43) | def test_choice_loader(self, choice_loader): method test_function_loader (line 51) | def test_function_loader(self, function_loader): method test_prefix_loader (line 57) | def test_prefix_loader(self, prefix_loader): method test_caching (line 65) | def test_caching(self): method test_no_cache (line 79) | def test_no_cache(self): method test_limited_size_cache (line 84) | def test_limited_size_cache(self): method test_cache_loader_change (line 98) | def test_cache_loader_change(self): method test_dict_loader_cache_invalidates (line 106) | def test_dict_loader_cache_invalidates(self): method test_split_template_path (line 113) | def test_split_template_path(self): class TestFileSystemLoader (line 119) | class TestFileSystemLoader: method _test_common (line 123) | def _test_common(env): method test_searchpath_as_str (line 130) | def test_searchpath_as_str(self): method test_searchpath_as_pathlib (line 136) | def test_searchpath_as_pathlib(self): method test_searchpath_as_list_including_pathlib (line 141) | def test_searchpath_as_list_including_pathlib(self): method test_caches_template_based_on_mtime (line 148) | def test_caches_template_based_on_mtime(self): method test_uses_specified_encoding (line 167) | def test_uses_specified_encoding(self, encoding, expect): method test_filename_normpath (line 173) | def test_filename_normpath(self): method test_error_includes_paths (line 182) | def test_error_includes_paths(self, env, filesystem_loader): class TestModuleLoader (line 201) | class TestModuleLoader: method compile_down (line 205) | def compile_down(self, prefix_loader, zip="deflated"): method teardown_method (line 217) | def teardown_method(self): method test_log (line 226) | def test_log(self, prefix_loader): method _test_common (line 238) | def _test_common(self): method test_deflated_zip_compile (line 247) | def test_deflated_zip_compile(self, prefix_loader): method test_stored_zip_compile (line 251) | def test_stored_zip_compile(self, prefix_loader): method test_filesystem_compile (line 255) | def test_filesystem_compile(self, prefix_loader): method test_weak_references (line 259) | def test_weak_references(self, prefix_loader): method test_choice_loader (line 280) | def test_choice_loader(self, prefix_loader): method test_prefix_loader (line 290) | def test_prefix_loader(self, prefix_loader): method test_path_as_pathlib (line 303) | def test_path_as_pathlib(self, prefix_loader): method test_supports_pathlib_in_list_of_paths (line 312) | def test_supports_pathlib_in_list_of_paths(self, prefix_loader): function package_dir_loader (line 323) | def package_dir_loader(monkeypatch): function test_package_dir_source (line 331) | def test_package_dir_source(package_dir_loader, template, expect): function test_package_dir_list (line 338) | def test_package_dir_list(package_dir_loader): function package_file_loader (line 345) | def package_file_loader(monkeypatch): function test_package_file_source (line 353) | def test_package_file_source(package_file_loader, template, expect): function test_package_file_list (line 360) | def test_package_file_list(package_file_loader): function package_zip_loader (line 367) | def package_zip_loader(monkeypatch): function test_package_zip_source (line 376) | def test_package_zip_source(package_zip_loader, template, expect): function test_package_zip_list (line 388) | def test_package_zip_list(package_zip_loader): function test_package_zip_omit_curdir (line 393) | def test_package_zip_omit_curdir(package_zip_loader, package_path): function test_pep_451_import_hook (line 403) | def test_pep_451_import_hook(): function test_package_loader_no_dir (line 434) | def test_package_loader_no_dir() -> None: FILE: tests/test_nativetypes.py function env (line 12) | def env(): function async_native_env (line 17) | def async_native_env(): function test_is_defined_native_return (line 21) | def test_is_defined_native_return(env): function test_undefined_native_return (line 26) | def test_undefined_native_return(env): function test_adding_undefined_native_return (line 31) | def test_adding_undefined_native_return(env): function test_cast_int (line 38) | def test_cast_int(env): function test_list_add (line 45) | def test_list_add(env): function test_multi_expression_add (line 52) | def test_multi_expression_add(env): function test_loops (line 59) | def test_loops(env): function test_loops_with_ints (line 66) | def test_loops_with_ints(env): function test_loop_look_alike (line 73) | def test_loop_look_alike(env): function test_booleans (line 91) | def test_booleans(env, source, expect): function test_variable_dunder (line 98) | def test_variable_dunder(env): function test_constant_dunder (line 104) | def test_constant_dunder(env): function test_constant_dunder_to_string (line 110) | def test_constant_dunder_to_string(env): function test_string_literal_var (line 117) | def test_string_literal_var(env): function test_string_top_level (line 124) | def test_string_top_level(env): function test_string_concatenation (line 130) | def test_string_concatenation(async_native_env, run_async_fn): function test_tuple_of_variable_strings (line 142) | def test_tuple_of_variable_strings(env): function test_concat_strings_with_quotes (line 149) | def test_concat_strings_with_quotes(env): function test_no_intermediate_eval (line 155) | def test_no_intermediate_eval(env): function test_spontaneous_env (line 164) | def test_spontaneous_env(): function test_leading_spaces (line 169) | def test_leading_spaces(env): function test_macro (line 175) | def test_macro(env): function test_block (line 182) | def test_block(env): FILE: tests/test_nodes.py function test_template_hash (line 1) | def test_template_hash(env): FILE: tests/test_pickle.py function test_environment (line 4) | def test_environment(env): FILE: tests/test_regression.py class TestCorner (line 13) | class TestCorner: method test_assigned_scoping (line 14) | def test_assigned_scoping(self, env): method test_closure_scoping (line 47) | def test_closure_scoping(self, env): class TestBug (line 84) | class TestBug: method test_keyword_folding (line 85) | def test_keyword_folding(self, env): method test_extends_output_bugs (line 93) | def test_extends_output_bugs(self, env): method test_urlize_filter_escaping (line 106) | def test_urlize_filter_escaping(self, env): method test_urlize_filter_closing_punctuation (line 113) | def test_urlize_filter_closing_punctuation(self, env): method test_loop_call_loop (line 122) | def test_loop_call_loop(self, env): method test_weird_inline_comment (line 143) | def test_weird_inline_comment(self, env): method test_old_macro_loop_scoping_bug (line 151) | def test_old_macro_loop_scoping_bug(self, env): method test_partial_conditional_assignments (line 158) | def test_partial_conditional_assignments(self, env): method test_stacked_locals_scoping_bug (line 163) | def test_stacked_locals_scoping_bug(self, env): method test_stacked_locals_scoping_bug_twoframe (line 189) | def test_stacked_locals_scoping_bug_twoframe(self, env): method test_call_with_args (line 204) | def test_call_with_args(self, env): method test_empty_if_condition_fails (line 245) | def test_empty_if_condition_fails(self, env): method test_recursive_loop_compile (line 252) | def test_recursive_loop_compile(self, env): method test_else_loop_bug (line 282) | def test_else_loop_bug(self, env): method test_correct_prefix_loader_name (line 294) | def test_correct_prefix_loader_name(self, env): method test_pass_context_callable_class (line 301) | def test_pass_context_callable_class(self, env): method test_block_set_with_extends (line 313) | def test_block_set_with_extends(self): method test_nested_for_else (line 320) | def test_nested_for_else(self, env): method test_macro_var_bug (line 328) | def test_macro_var_bug(self, env): method test_macro_var_bug_advanced (line 339) | def test_macro_var_bug_advanced(self, env): method test_callable_defaults (line 352) | def test_callable_defaults(self): method test_macro_escaping (line 365) | def test_macro_escaping(self): method test_macro_scoping (line 371) | def test_macro_scoping(self, env): method test_scopes_and_blocks (line 389) | def test_scopes_and_blocks(self): method test_scopes_and_include (line 419) | def test_scopes_and_include(self): method test_caller_scoping (line 432) | def test_caller_scoping(self, env): method test_variable_reuse (line 459) | def test_variable_reuse(self, env): method test_double_caller (line 469) | def test_double_caller(self, env): method test_double_caller_no_default (line 477) | def test_double_caller_no_default(self, env): method test_macro_blocks (line 497) | def test_macro_blocks(self, env): method test_scoped_block (line 503) | def test_scoped_block(self, env): method test_recursive_loop_filter (line 510) | def test_recursive_loop_filter(self, env): method test_empty_if (line 535) | def test_empty_if(self, env): method test_subproperty_if (line 539) | def test_subproperty_if(self, env): method test_set_and_include (line 550) | def test_set_and_include(self): method test_loop_include (line 561) | def test_loop_include(self): method test_grouper_repr (line 572) | def test_grouper_repr(self): method test_custom_context (line 581) | def test_custom_context(self, env): method test_recursive_loop_bug (line 594) | def test_recursive_loop_bug(self, env): method test_markup_and_chainable_undefined (line 600) | def test_markup_and_chainable_undefined(self): method test_scoped_block_loop_vars (line 607) | def test_scoped_block_loop_vars(self, env): method test_pass_context_loop_vars (line 620) | def test_pass_context_loop_vars(self, env): method test_pass_context_scoped_loop_vars (line 640) | def test_pass_context_scoped_loop_vars(self, env): method test_pass_context_in_blocks (line 660) | def test_pass_context_in_blocks(self, env): method test_pass_context_block_and_loop (line 678) | def test_pass_context_block_and_loop(self, env): method test_cached_extends (line 705) | def test_cached_extends(self, op): method test_nested_loop_scoping (line 733) | def test_nested_loop_scoping(self, env): method test_pass_context_with_select (line 740) | def test_pass_context_with_select(self, env): function test_load_parameter_when_set_in_all_if_branches (line 753) | def test_load_parameter_when_set_in_all_if_branches(env): function test_unicode_whitespace (line 764) | def test_unicode_whitespace(env, unicode_char): FILE: tests/test_runtime.py function test_loop_idx (line 26) | def test_loop_idx(): function test_loop_idx0 (line 33) | def test_loop_idx0(): function test_loopcontext0 (line 40) | def test_loopcontext0(): function test_loopcontext1 (line 46) | def test_loopcontext1(): function test_loopcontext2 (line 52) | def test_loopcontext2(): function test_iterator_not_advanced_early (line 58) | def test_iterator_not_advanced_early(): function test_mock_not_pass_arg_marker (line 68) | def test_mock_not_pass_arg_marker(): function test_undefined_copy (line 91) | def test_undefined_copy(undefined_type): function test_undefined_deepcopy (line 103) | def test_undefined_deepcopy(undefined_type): function test_undefined_pickle (line 115) | def test_undefined_pickle(undefined_type): FILE: tests/test_security.py class PrivateStuff (line 14) | class PrivateStuff: method bar (line 15) | def bar(self): method foo (line 19) | def foo(self): method __repr__ (line 22) | def __repr__(self): class PublicStuff (line 26) | class PublicStuff: method bar (line 27) | def bar(self): method _foo (line 30) | def _foo(self): method __repr__ (line 33) | def __repr__(self): class TestSandbox (line 37) | class TestSandbox: method test_unsafe (line 38) | def test_unsafe(self, env): method test_immutable_environment (line 58) | def test_immutable_environment(self, env): method test_restricted (line 65) | def test_restricted(self, env): method test_template_data (line 78) | def test_template_data(self, env): method test_attr_filter (line 96) | def test_attr_filter(self, env): method test_binary_operator_intercepting (line 101) | def test_binary_operator_intercepting(self, env): method test_unary_operator_intercepting (line 115) | def test_unary_operator_intercepting(self, env): class TestStringFormat (line 130) | class TestStringFormat: method test_basic_format_safety (line 131) | def test_basic_format_safety(self): method test_basic_format_all_okay (line 136) | def test_basic_format_all_okay(self): method test_safe_format_safety (line 141) | def test_safe_format_safety(self): method test_safe_format_all_okay (line 146) | def test_safe_format_all_okay(self): method test_empty_braces_format (line 151) | def test_empty_braces_format(self): class TestStringFormatMap (line 159) | class TestStringFormatMap: method test_basic_format_safety (line 160) | def test_basic_format_safety(self): method test_basic_format_all_okay (line 165) | def test_basic_format_all_okay(self): method test_safe_format_all_okay (line 170) | def test_safe_format_all_okay(self): method test_indirect_call (line 177) | def test_indirect_call(self): method test_attr_filter (line 194) | def test_attr_filter(self) -> None: FILE: tests/test_tests.py class MyDict (line 9) | class MyDict(dict): class TestTestsCase (line 13) | class TestTestsCase: method test_defined (line 14) | def test_defined(self, env): method test_even (line 18) | def test_even(self, env): method test_odd (line 22) | def test_odd(self, env): method test_lower (line 26) | def test_lower(self, env): method test_types (line 113) | def test_types(self, env, op, expect): method test_upper (line 117) | def test_upper(self, env): method test_equalto (line 121) | def test_equalto(self, env): method test_compare_aliases (line 154) | def test_compare_aliases(self, env, op, expect): method test_sameas (line 158) | def test_sameas(self, env): method test_no_paren_for_arg1 (line 162) | def test_no_paren_for_arg1(self, env): method test_escaped (line 166) | def test_escaped(self, env): method test_greaterthan (line 171) | def test_greaterthan(self, env): method test_lessthan (line 175) | def test_lessthan(self, env): method test_multiple_tests (line 179) | def test_multiple_tests(self): method test_in (line 198) | def test_in(self, env): function test_name_undefined (line 213) | def test_name_undefined(env): function test_name_undefined_in_if (line 218) | def test_name_undefined_in_if(env): function test_is_filter (line 226) | def test_is_filter(env): function test_is_test (line 231) | def test_is_test(env): FILE: tests/test_utils.py class TestLRUCache (line 19) | class TestLRUCache: method test_simple (line 20) | def test_simple(self): method test_values (line 29) | def test_values(self): method test_values_empty (line 35) | def test_values_empty(self): method test_pickleable (line 39) | def test_pickleable(self): method test_copy (line 52) | def test_copy(self, copy_func): method test_clear (line 62) | def test_clear(self): method test_repr (line 70) | def test_repr(self): method test_items (line 78) | def test_items(self): method test_setdefault (line 97) | def test_setdefault(self): class TestHelpers (line 107) | class TestHelpers: method test_object_type_repr (line 108) | def test_object_type_repr(self): method test_autoescape_select (line 118) | def test_autoescape_select(self): class TestEscapeUrlizeTarget (line 135) | class TestEscapeUrlizeTarget: method test_escape_urlize_target (line 136) | def test_escape_urlize_target(self): method test_urlize_mail_mastodon (line 145) | def test_urlize_mail_mastodon(self): class TestLoremIpsum (line 154) | class TestLoremIpsum: method test_lorem_ipsum_markup (line 155) | def test_lorem_ipsum_markup(self): method test_lorem_ipsum_html (line 159) | def test_lorem_ipsum_html(self): method test_lorem_ipsum_n (line 163) | def test_lorem_ipsum_n(self): method test_lorem_ipsum_min (line 169) | def test_lorem_ipsum_min(self): method test_lorem_ipsum_max (line 176) | def test_lorem_ipsum_max(self): function test_missing (line 184) | def test_missing(): function test_consume (line 189) | def test_consume(): function test_pickle_missing (line 198) | def test_pickle_missing(protocol: int) -> None: function test_copy_missing (line 203) | def test_copy_missing() -> None: