golden hour

/usr/lib/python2.7/site-packages/jinja2

File/Folder	Size	Actions
__init__.py	2.22 KB
__init__.pyc	2.38 KB
__init__.pyo	2.38 KB
_compat.py	3.95 KB
_compat.pyc	5.99 KB
_compat.pyo	5.99 KB
_stringdefs.py	394.82 KB
_stringdefs.pyc	203.64 KB
_stringdefs.pyo	203.64 KB
bccache.py	12.04 KB
bccache.pyc	13.85 KB
bccache.pyo	13.85 KB
compiler.py	60.34 KB
compiler.pyc	53.21 KB
compiler.pyo	53.15 KB
constants.py	1.59 KB
constants.pyc	1.65 KB
constants.pyo	1.65 KB
debug.py	10.72 KB
debug.pyc	10.45 KB
debug.pyo	10.37 KB
defaults.py	1.03 KB
defaults.pyc	1.46 KB
defaults.pyo	1.46 KB
environment.py	46.14 KB
environment.pyc	45 KB
environment.pyo	44.59 KB
exceptions.py	4.32 KB
exceptions.pyc	6.11 KB
exceptions.pyo	6.11 KB
ext.py	24.49 KB
ext.pyc	23.5 KB
ext.pyo	23.43 KB
filters.py	29.14 KB
filters.pyc	33.13 KB
filters.pyo	33.13 KB
lexer.py	27.73 KB
lexer.pyc	22.11 KB
lexer.pyo	21.95 KB
loaders.py	16.64 KB
loaders.pyc	18.5 KB
loaders.pyo	18.5 KB
meta.py	4.09 KB
meta.pyc	3.92 KB
meta.pyo	3.92 KB
nodes.py	28.23 KB
nodes.pyc	41.54 KB
nodes.pyo	41.06 KB
optimizer.py	2.25 KB
optimizer.pyc	2.78 KB
optimizer.pyo	2.78 KB
parser.py	34.36 KB
parser.pyc	30.5 KB
parser.pyo	30.5 KB
runtime.py	19.1 KB
runtime.pyc	22.5 KB
runtime.pyo	22.46 KB
sandbox.py	18.09 KB
sandbox.pyc	17.23 KB
sandbox.pyo	17.23 KB
tests.py	3.36 KB
tests.pyc	4.93 KB
tests.pyo	4.93 KB
testsuite	-
utils.py	15.79 KB
utils.pyc	19.08 KB
utils.pyo	19.08 KB
visitor.py	3.24 KB
visitor.pyc	3.72 KB
visitor.pyo	3.72 KB

Edit: meta.py

# -*- coding: utf-8 -*-
"""
    jinja2.meta
    ~~~~~~~~~~~

This module implements various functions that exposes information about
    templates that might be interesting for various kinds of applications.

:copyright: (c) 2010 by the Jinja Team, see AUTHORS for more details.
    :license: BSD, see LICENSE for more details.
"""
from jinja2 import nodes
from jinja2.compiler import CodeGenerator
from jinja2._compat import string_types

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 pull_locals(self, frame):
        """Remember all undeclared identifiers."""
        self.undeclared_identifiers.update(frame.identifiers.undeclared)

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'])

.. 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