ACIL FM

Nama	Ukuran	Aksi
__pycache__	-	Open
asyncfilters.py	4.15 MB	View DL Edit
asyncsupport.py	7.04 MB	View DL Edit
bccache.py	11.85 MB	View DL Edit
compiler.py	64.73 MB	View DL Edit
constants.py	1.42 MB	View DL Edit
debug.py	8.37 MB	View DL Edit
defaults.py	1.1 MB	View DL Edit
environment.py	49.44 MB	View DL Edit
exceptions.py	5.3 MB	View DL Edit
ext.py	25.82 MB	View DL Edit
filters.py	41.41 MB	View DL Edit
idtracking.py	9 MB	View DL Edit
lexer.py	29.62 MB	View DL Edit
loaders.py	17.25 MB	View DL Edit
meta.py	4.03 MB	View DL Edit
nativetypes.py	2.75 MB	View DL Edit
nodes.py	30.37 MB	View DL Edit
optimizer.py	1.42 MB	View DL Edit
parser.py	34.82 MB	View DL Edit
runtime.py	29.9 MB	View DL Edit
sandbox.py	17.12 MB	View DL Edit
tests.py	4.69 MB	View DL Edit
utils.py	21.91 MB	View DL Edit
visitor.py	3.16 MB	View DL Edit
_compat.py	3.12 MB	View DL Edit
_identifier.py	1.73 MB	View DL Edit
__init__.py	1.51 MB	View DL Edit

Edit file: /usr/lib/python3.9/site-packages/jinja2/meta.py

# -*- coding: utf-8 -*-
"""Functions that expose information about templates that might be
interesting for introspection.
"""
from . import nodes
from ._compat import iteritems
from ._compat import string_types
from .compiler import CodeGenerator

class TrackingCodeGenerator(CodeGenerator):
    """We abuse the code generator for introspection."""

def __init__(self, environment):
        CodeGenerator.__init__(self, environment, "<introspection>", "<introspection>")
        self.undeclared_identifiers = set()

def write(self, x):
        """Don't write."""

def enter_frame(self, frame):
        """Remember all undeclared identifiers."""
        CodeGenerator.enter_frame(self, frame)
        for _, (action, param) in iteritems(frame.symbols.loads):
            if action == "resolve" and param not in self.environment.globals:
                self.undeclared_identifiers.add(param)

def find_undeclared_variables(ast):
    """Returns a set of all variables in the AST that will be looked up from
    the context at runtime.  Because at compile time it's not known which
    variables will be used depending on the path the execution takes at
    runtime, all variables are returned.

>>> from jinja2 import Environment, meta
    >>> env = Environment()
    >>> ast = env.parse('{% set foo = 42 %}{{ bar + foo }}')
    >>> meta.find_undeclared_variables(ast) == set(['bar'])
    True

.. admonition:: Implementation

Internally the code generator is used for finding undeclared variables.
       This is good to know because the code generator might raise a
       :exc:`TemplateAssertionError` during compilation and as a matter of
       fact this function can currently raise that exception as well.
    """
    codegen = TrackingCodeGenerator(ast.environment)
    codegen.visit(ast)
    return codegen.undeclared_identifiers

def find_referenced_templates(ast):
    """Finds all the referenced templates from the AST.  This will return an
    iterator over all the hardcoded template extensions, inclusions and
    imports.  If dynamic inheritance or inclusion is used, `None` will be
    yielded.

>>> from jinja2 import Environment, meta
    >>> env = Environment()
    >>> ast = env.parse('{% extends "layout.html" %}{% include helper %}')
    >>> list(meta.find_referenced_templates(ast))
    ['layout.html', None]

This function is useful for dependency tracking.  For example if you want
    to rebuild parts of the website after a layout template has changed.
    """
    for node in ast.find_all(
        (nodes.Extends, nodes.FromImport, nodes.Import, nodes.Include)
    ):
        if not isinstance(node.template, nodes.Const):
            # a tuple with some non consts in there
            if isinstance(node.template, (nodes.Tuple, nodes.List)):
                for template_name in node.template.items:
                    # something const, only yield the strings and ignore
                    # non-string consts that really just make no sense
                    if isinstance(template_name, nodes.Const):
                        if isinstance(template_name.value, string_types):
                            yield template_name.value
                    # something dynamic in there
                    else:
                        yield None
            # something dynamic we don't know about here
            else:
                yield None
            continue
        # constant is a basestring, direct template name
        if isinstance(node.template.value, string_types):
            yield node.template.value
        # a tuple or list (latter *should* not happen) made of consts,
        # yield the consts that are strings.  We could warn here for
        # non string values
        elif isinstance(node, nodes.Include) and isinstance(
            node.template.value, (tuple, list)
        ):
            for template_name in node.template.value:
                if isinstance(template_name, string_types):
                    yield template_name
        # something else we don't care about, we could warn here
        else:
            yield None

Batal