FM / jinja2

/opt/imunify360/venv/lib/python3.11/site-packages/jinja2/

/opt/imunify360/venv/lib/python3.11/site-packages/jinja2

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
asyncfilters.py	4250	0644	edit dl rm
asyncsupport.py	7209	0644	edit dl rm
bccache.py	12139	0644	edit dl rm
compiler.py	66284	0644	edit dl rm
constants.py	1458	0644	edit dl rm
debug.py	8529	0644	edit dl rm
defaults.py	1126	0644	edit dl rm
environment.py	50629	0644	edit dl rm
exceptions.py	5425	0644	edit dl rm
ext.py	26441	0644	edit dl rm
filters.py	41415	0644	edit dl rm
idtracking.py	9211	0644	edit dl rm
lexer.py	30331	0644	edit dl rm
loaders.py	17666	0644	edit dl rm
meta.py	4131	0644	edit dl rm
nativetypes.py	2753	0644	edit dl rm
nodes.py	31095	0644	edit dl rm
optimizer.py	1457	0644	edit dl rm
parser.py	35660	0644	edit dl rm
runtime.py	30618	0644	edit dl rm
sandbox.py	17127	0644	edit dl rm
tests.py	4799	0644	edit dl rm
utils.py	22522	0644	edit dl rm
visitor.py	3240	0644	edit dl rm
_compat.py	3191	0644	edit dl rm
_identifier.py	1775	0644	edit dl rm
__init__.py	1549	0644	edit dl rm

Edit: /opt/imunify360/venv/lib/python3.11/site-packages/jinja2/optimizer.py (1457B)

# -*- coding: utf-8 -*-
"""The optimizer tries to constant fold expressions and modify the AST
in place so that it should be faster to evaluate.

Because the AST does not contain all the scoping information and the
compiler has to find that out, we cannot do all the optimizations we
want. For example, loop unrolling doesn't work because unrolled loops
would have a different scope. The solution would be a second syntax tree
that stored the scoping rules.
"""
from . import nodes
from .visitor import NodeTransformer

def optimize(node, environment):
    """The context hint can be used to perform an static optimization
    based on the context given."""
    optimizer = Optimizer(environment)
    return optimizer.visit(node)

class Optimizer(NodeTransformer):
    def __init__(self, environment):
        self.environment = environment

def generic_visit(self, node, *args, **kwargs):
        node = super(Optimizer, self).generic_visit(node, *args, **kwargs)

# Do constant folding. Some other nodes besides Expr have
        # as_const, but folding them causes errors later on.
        if isinstance(node, nodes.Expr):
            try:
                return nodes.Const.from_untrusted(
                    node.as_const(args[0] if args else None),
                    lineno=node.lineno,
                    environment=self.environment,
                )
            except nodes.Impossible:
                pass

return node

# -*- coding: utf-8 -*- """The optimizer tries to constant fold expressions and modify the AST in place so that it should be faster to evaluate. Because the AST does not contain all the scoping information and the compiler has to find that out, we cannot do all the optimizations we want. For example, loop unrolling doesn't work because unrolled loops would have a different scope. The solution would be a second syntax tree that stored the scoping rules. """ from . import nodes from .visitor import NodeTransformer def optimize(node, environment): """The context hint can be used to perform an static optimization based on the context given.""" optimizer = Optimizer(environment) return optimizer.visit(node) class Optimizer(NodeTransformer): def __init__(self, environment): self.environment = environment def generic_visit(self, node, *args, **kwargs): node = super(Optimizer, self).generic_visit(node, *args, **kwargs) # Do constant folding. Some other nodes besides Expr have # as_const, but folding them causes errors later on. if isinstance(node, nodes.Expr): try: return nodes.Const.from_untrusted( node.as_const(args[0] if args else None), lineno=node.lineno, environment=self.environment, ) except nodes.Impossible: pass return node