Gecko [ gtgates.com ]

Name	Size	Permission	Date
__init__.py	2.55 KB	-rw-r--r--	2017-11-08 19:58
__init__.pyc	2.82 KB	-rw-r--r--	2024-04-10 04:46
__init__.pyo	2.82 KB	-rw-r--r--	2024-04-10 04:46
_compat.py	2.54 KB	-rw-r--r--	2017-07-07 19:41
_compat.pyc	4.33 KB	-rw-r--r--	2024-04-10 04:46
_compat.pyo	4.33 KB	-rw-r--r--	2024-04-10 04:46
_identifier.py	1.69 KB	-rw-r--r--	2017-07-08 16:20
_identifier.pyc	1.78 KB	-rw-r--r--	2024-04-10 04:46
_identifier.pyo	1.78 KB	-rw-r--r--	2024-04-10 04:46
bccache.py	12.49 KB	-rw-r--r--	2017-07-08 16:20
bccache.pyc	14.15 KB	-rw-r--r--	2024-04-10 04:46
bccache.pyo	14.15 KB	-rw-r--r--	2024-04-10 04:46
compiler.py	63.85 KB	-rw-r--r--	2017-11-01 13:47
compiler.pyc	55.68 KB	-rw-r--r--	2024-04-10 04:46
compiler.pyo	55.62 KB	-rw-r--r--	2024-04-10 04:46
constants.py	1.59 KB	-rw-r--r--	2017-07-07 19:41
constants.pyc	1.65 KB	-rw-r--r--	2024-04-10 04:46
constants.pyo	1.65 KB	-rw-r--r--	2024-04-10 04:46
debug.py	11.76 KB	-rw-r--r--	2017-10-31 20:10
debug.pyc	11.13 KB	-rw-r--r--	2024-04-10 04:46
debug.pyo	11.06 KB	-rw-r--r--	2024-04-10 04:46
defaults.py	1.37 KB	-rw-r--r--	2017-07-08 16:20
defaults.pyc	1.78 KB	-rw-r--r--	2024-04-10 04:46
defaults.pyo	1.78 KB	-rw-r--r--	2024-04-10 04:46
environment.py	49.66 KB	-rw-r--r--	2017-10-31 20:46
environment.pyc	48.23 KB	-rw-r--r--	2024-04-10 04:46
environment.pyo	47.82 KB	-rw-r--r--	2024-04-10 04:46
exceptions.py	4.32 KB	-rw-r--r--	2017-07-07 19:41
exceptions.pyc	6.11 KB	-rw-r--r--	2024-04-10 04:46
exceptions.pyo	6.11 KB	-rw-r--r--	2024-04-10 04:46
ext.py	23.93 KB	-rw-r--r--	2017-07-08 16:20
ext.pyc	22.83 KB	-rw-r--r--	2024-04-10 04:46
ext.pyo	22.76 KB	-rw-r--r--	2024-04-10 04:46
filters.py	35.94 KB	-rw-r--r--	2024-04-10 04:46
filters.pyc	39.28 KB	-rw-r--r--	2024-04-10 04:46
filters.pyo	39.12 KB	-rw-r--r--	2024-04-10 04:46
idtracking.py	8.98 KB	-rw-r--r--	2017-10-31 20:10
idtracking.pyc	12.21 KB	-rw-r--r--	2024-04-10 04:46
idtracking.pyo	12.16 KB	-rw-r--r--	2024-04-10 04:46
lexer.py	27.89 KB	-rw-r--r--	2017-10-31 20:10
lexer.pyc	22.3 KB	-rw-r--r--	2024-04-10 04:46
lexer.pyo	22.15 KB	-rw-r--r--	2024-04-10 04:46
loaders.py	16.97 KB	-rw-r--r--	2017-07-07 19:41
loaders.pyc	18.79 KB	-rw-r--r--	2024-04-10 04:46
loaders.pyo	18.79 KB	-rw-r--r--	2024-04-10 04:46
meta.py	4.24 KB	-rw-r--r--	2017-07-07 19:41
meta.pyc	4.06 KB	-rw-r--r--	2024-04-10 04:46
meta.pyo	4.06 KB	-rw-r--r--	2024-04-10 04:46
nativetypes.py	7.14 KB	-rw-r--r--	2017-10-31 20:46
nativetypes.pyc	5.98 KB	-rw-r--r--	2024-04-10 04:46
nativetypes.pyo	5.98 KB	-rw-r--r--	2024-04-10 04:46
nodes.py	30.13 KB	-rw-r--r--	2017-11-01 13:47
nodes.pyc	43.52 KB	-rw-r--r--	2024-04-10 04:46
nodes.pyo	43.04 KB	-rw-r--r--	2024-04-10 04:46
optimizer.py	1.68 KB	-rw-r--r--	2017-11-08 19:47
optimizer.pyc	2.32 KB	-rw-r--r--	2024-04-10 04:46
optimizer.pyo	2.32 KB	-rw-r--r--	2024-04-10 04:46
parser.py	35.03 KB	-rw-r--r--	2017-11-01 13:47
parser.pyc	30.84 KB	-rw-r--r--	2024-04-10 04:46
parser.pyo	30.84 KB	-rw-r--r--	2024-04-10 04:46
runtime.py	27.1 KB	-rw-r--r--	2017-10-31 20:10
runtime.pyc	29.34 KB	-rw-r--r--	2024-04-10 04:46
runtime.pyo	29.3 KB	-rw-r--r--	2024-04-10 04:46
sandbox.py	16.32 KB	-rw-r--r--	2017-07-08 16:20
sandbox.pyc	16 KB	-rw-r--r--	2024-04-10 04:46
sandbox.pyo	16 KB	-rw-r--r--	2024-04-10 04:46
tests.py	4.14 KB	-rw-r--r--	2017-10-31 20:10
tests.pyc	5.62 KB	-rw-r--r--	2024-04-10 04:46
tests.pyo	5.62 KB	-rw-r--r--	2024-04-10 04:46
utils.py	20.29 KB	-rw-r--r--	2024-04-10 04:46
utils.pyc	24.02 KB	-rw-r--r--	2024-04-10 04:46
utils.pyo	24.02 KB	-rw-r--r--	2024-04-10 04:46
visitor.py	3.24 KB	-rw-r--r--	2017-07-07 19:41
visitor.pyc	3.72 KB	-rw-r--r--	2024-04-10 04:46
visitor.pyo	3.72 KB	-rw-r--r--	2024-04-10 04:46

Rename

import sys
from ast import literal_eval
from itertools import islice, chain
from jinja2 import nodes
from jinja2._compat import text_type
from jinja2.compiler import CodeGenerator, has_safe_repr
from jinja2.environment import Environment, Template
from jinja2.utils import concat, escape

def native_concat(nodes):
    """Return a native Python type from the list of compiled nodes. If the
    result is a single node, its value is returned. Otherwise, the nodes are
    concatenated as strings. If the result can be parsed with
    :func:`ast.literal_eval`, the parsed value is returned. Otherwise, the
    string is returned.
    """
    head = list(islice(nodes, 2))

if not head:
        return None

if len(head) == 1:
        out = head[0]
    else:
        out = u''.join([text_type(v) for v in chain(head, nodes)])

try:
        return literal_eval(out)
    except (ValueError, SyntaxError, MemoryError):
        return out

class NativeCodeGenerator(CodeGenerator):
    """A code generator which avoids injecting ``to_string()`` calls around the
    internal code Jinja uses to render templates.
    """

def visit_Output(self, node, frame):
        """Same as :meth:`CodeGenerator.visit_Output`, but do not call
        ``to_string`` on output nodes in generated code.
        """
        if self.has_known_extends and frame.require_output_check:
            return

finalize = self.environment.finalize
        finalize_context = getattr(finalize, 'contextfunction', False)
        finalize_eval = getattr(finalize, 'evalcontextfunction', False)
        finalize_env = getattr(finalize, 'environmentfunction', False)

if finalize is not None:
            if finalize_context or finalize_eval:
                const_finalize = None
            elif finalize_env:
                def const_finalize(x):
                    return finalize(self.environment, x)
            else:
                const_finalize = finalize
        else:
            def const_finalize(x):
                return x

# If we are inside a frame that requires output checking, we do so.
        outdent_later = False

if frame.require_output_check:
            self.writeline('if parent_template is None:')
            self.indent()
            outdent_later = True

# Try to evaluate as many chunks as possible into a static string at
        # compile time.
        body = []

for child in node.nodes:
            try:
                if const_finalize is None:
                    raise nodes.Impossible()

const = child.as_const(frame.eval_ctx)
                if not has_safe_repr(const):
                    raise nodes.Impossible()
            except nodes.Impossible:
                body.append(child)
                continue

# the frame can't be volatile here, because otherwise the as_const
            # function would raise an Impossible exception at that point
            try:
                if frame.eval_ctx.autoescape:
                    if hasattr(const, '__html__'):
                        const = const.__html__()
                    else:
                        const = escape(const)

const = const_finalize(const)
            except Exception:
                # if something goes wrong here we evaluate the node at runtime
                # for easier debugging
                body.append(child)
                continue

if body and isinstance(body[-1], list):
                body[-1].append(const)
            else:
                body.append([const])

# if we have less than 3 nodes or a buffer we yield or extend/append
        if len(body) < 3 or frame.buffer is not None:
            if frame.buffer is not None:
                # for one item we append, for more we extend
                if len(body) == 1:
                    self.writeline('%s.append(' % frame.buffer)
                else:
                    self.writeline('%s.extend((' % frame.buffer)

self.indent()

for item in body:
                if isinstance(item, list):
                    val = repr(native_concat(item))

if frame.buffer is None:
                        self.writeline('yield ' + val)
                    else:
                        self.writeline(val + ',')
                else:
                    if frame.buffer is None:
                        self.writeline('yield ', item)
                    else:
                        self.newline(item)

close = 0

if finalize is not None:
                        self.write('environment.finalize(')

if finalize_context:
                            self.write('context, ')

close += 1

self.visit(item, frame)

if close > 0:
                        self.write(')' * close)

if frame.buffer is not None:
                        self.write(',')

if frame.buffer is not None:
                # close the open parentheses
                self.outdent()
                self.writeline(len(body) == 1 and ')' or '))')

# otherwise we create a format string as this is faster in that case
        else:
            format = []
            arguments = []

for item in body:
                if isinstance(item, list):
                    format.append(native_concat(item).replace('%', '%%'))
                else:
                    format.append('%s')
                    arguments.append(item)

self.writeline('yield ')
            self.write(repr(concat(format)) + ' % (')
            self.indent()

for argument in arguments:
                self.newline(argument)
                close = 0

if finalize is not None:
                    self.write('environment.finalize(')

if finalize_context:
                        self.write('context, ')
                    elif finalize_eval:
                        self.write('context.eval_ctx, ')
                    elif finalize_env:
                        self.write('environment, ')

close += 1

self.visit(argument, frame)
                self.write(')' * close + ', ')

self.outdent()
            self.writeline(')')

if outdent_later:
            self.outdent()

class NativeTemplate(Template):
    def render(self, *args, **kwargs):
        """Render the template to produce a native Python type. If the result
        is a single node, its value is returned. Otherwise, the nodes are
        concatenated as strings. If the result can be parsed with
        :func:`ast.literal_eval`, the parsed value is returned. Otherwise, the
        string is returned.
        """
        vars = dict(*args, **kwargs)

try:
            return native_concat(self.root_render_func(self.new_context(vars)))
        except Exception:
            exc_info = sys.exc_info()

return self.environment.handle_exception(exc_info, True)

class NativeEnvironment(Environment):
    """An environment that renders templates to native Python types."""

code_generator_class = NativeCodeGenerator
    template_class = NativeTemplate