springsuite: planemo/lib/python3.7/site-packages/jinja2/nodes.py comparison

comparison planemo/lib/python3.7/site-packages/jinja2/nodes.py @ 1:56ad4e20f292 draft

"planemo upload commit 6eee67778febed82ddd413c3ca40b3183a3898f1"

author	guerler
date	Fri, 31 Jul 2020 00:32:28 -0400
parents
children

comparison

equal deleted inserted replaced

-:d30785e31577
+:56ad4e20f292
+# -*- coding: utf-8 -*-
+"""AST nodes generated by the parser for the compiler. Also provides
+some node tree helper functions used by the parser and compiler in order
+to normalize nodes.
+"""
+import operator
+from collections import deque
+from markupsafe import Markup
+from ._compat import izip
+from ._compat import PY2
+from ._compat import text_type
+from ._compat import with_metaclass
+_binop_to_func = {
+"*": operator.mul,
+"/": operator.truediv,
+"//": operator.floordiv,
+"**": operator.pow,
+"%": operator.mod,
+"+": operator.add,
+"-": operator.sub,
+}
+_uaop_to_func = {"not": operator.not_, "+": operator.pos, "-": operator.neg}
+_cmpop_to_func = {
+"eq": operator.eq,
+"ne": operator.ne,
+"gt": operator.gt,
+"gteq": operator.ge,
+"lt": operator.lt,
+"lteq": operator.le,
+"in": lambda a, b: a in b,
+"notin": lambda a, b: a not in b,
+}
+class Impossible(Exception):
+"""Raised if the node could not perform a requested action."""
+class NodeType(type):
+"""A metaclass for nodes that handles the field and attribute
+inheritance.  fields and attributes from the parent class are
+automatically forwarded to the child."""
+def __new__(mcs, name, bases, d):
+for attr in "fields", "attributes":
+storage = []
+storage.extend(getattr(bases[0], attr, ()))
+storage.extend(d.get(attr, ()))
+assert len(bases) == 1, "multiple inheritance not allowed"
+assert len(storage) == len(set(storage)), "layout conflict"
+d[attr] = tuple(storage)
+d.setdefault("abstract", False)
+return type.__new__(mcs, name, bases, d)
+class EvalContext(object):
+"""Holds evaluation time information.  Custom attributes can be attached
+to it in extensions.
+"""
+def __init__(self, environment, template_name=None):
+self.environment = environment
+if callable(environment.autoescape):
+self.autoescape = environment.autoescape(template_name)
+else:
+self.autoescape = environment.autoescape
+self.volatile = False
+def save(self):
+return self.__dict__.copy()
+def revert(self, old):
+self.__dict__.clear()
+self.__dict__.update(old)
+def get_eval_context(node, ctx):
+if ctx is None:
+if node.environment is None:
+raise RuntimeError(
+"if no eval context is passed, the "
+"node must have an attached "
+"environment."
+)
+return EvalContext(node.environment)
+return ctx
+class Node(with_metaclass(NodeType, object)):
+"""Baseclass for all Jinja nodes.  There are a number of nodes available
+of different types.  There are four major types:
+-   :class:`Stmt`: statements
+-   :class:`Expr`: expressions
+-   :class:`Helper`: helper nodes
+-   :class:`Template`: the outermost wrapper node
+All nodes have fields and attributes.  Fields may be other nodes, lists,
+or arbitrary values.  Fields are passed to the constructor as regular
+positional arguments, attributes as keyword arguments.  Each node has
+two attributes: `lineno` (the line number of the node) and `environment`.
+The `environment` attribute is set at the end of the parsing process for
+all nodes automatically.
+"""
+fields = ()
+attributes = ("lineno", "environment")
+abstract = True
+def __init__(self, *fields, **attributes):
+if self.abstract:
+raise TypeError("abstract nodes are not instantiable")
+if fields:
+if len(fields) != len(self.fields):
+if not self.fields:
+raise TypeError("%r takes 0 arguments" % self.__class__.__name__)
+raise TypeError(
+"%r takes 0 or %d argument%s"
+% (
+self.__class__.__name__,
+len(self.fields),
+len(self.fields) != 1 and "s" or "",
+)
+)
+for name, arg in izip(self.fields, fields):
+setattr(self, name, arg)
+for attr in self.attributes:
+setattr(self, attr, attributes.pop(attr, None))
+if attributes:
+raise TypeError("unknown attribute %r" % next(iter(attributes)))
+def iter_fields(self, exclude=None, only=None):
+"""This method iterates over all fields that are defined and yields
+``(key, value)`` tuples.  Per default all fields are returned, but
+it's possible to limit that to some fields by providing the `only`
+parameter or to exclude some using the `exclude` parameter.  Both
+should be sets or tuples of field names.
+"""
+for name in self.fields:
+if (
+(exclude is only is None)
+or (exclude is not None and name not in exclude)
+or (only is not None and name in only)
+):
+try:
+yield name, getattr(self, name)
+except AttributeError:
+pass
+def iter_child_nodes(self, exclude=None, only=None):
+"""Iterates over all direct child nodes of the node.  This iterates
+over all fields and yields the values of they are nodes.  If the value
+of a field is a list all the nodes in that list are returned.
+"""
+for _, item in self.iter_fields(exclude, only):
+if isinstance(item, list):
+for n in item:
+if isinstance(n, Node):
+yield n
+elif isinstance(item, Node):
+yield item
+def find(self, node_type):
+"""Find the first node of a given type.  If no such node exists the
+return value is `None`.
+"""
+for result in self.find_all(node_type):
+return result
+def find_all(self, node_type):
+"""Find all the nodes of a given type.  If the type is a tuple,
+the check is performed for any of the tuple items.
+"""
+for child in self.iter_child_nodes():
+if isinstance(child, node_type):
+yield child
+for result in child.find_all(node_type):
+yield result
+def set_ctx(self, ctx):
+"""Reset the context of a node and all child nodes.  Per default the
+parser will all generate nodes that have a 'load' context as it's the
+most common one.  This method is used in the parser to set assignment
+targets and other nodes to a store context.
+"""
+todo = deque([self])
+while todo:
+node = todo.popleft()
+if "ctx" in node.fields:
+node.ctx = ctx
+todo.extend(node.iter_child_nodes())
+return self
+def set_lineno(self, lineno, override=False):
+"""Set the line numbers of the node and children."""
+todo = deque([self])
+while todo:
+node = todo.popleft()
+if "lineno" in node.attributes:
+if node.lineno is None or override:
+node.lineno = lineno
+todo.extend(node.iter_child_nodes())
+return self
+def set_environment(self, environment):
+"""Set the environment for all nodes."""
+todo = deque([self])
+while todo:
+node = todo.popleft()
+node.environment = environment
+todo.extend(node.iter_child_nodes())
+return self
+def __eq__(self, other):
+return type(self) is type(other) and tuple(self.iter_fields()) == tuple(
+other.iter_fields()
+)
+def __ne__(self, other):
+return not self.__eq__(other)
+# Restore Python 2 hashing behavior on Python 3
+__hash__ = object.__hash__
+def __repr__(self):
+return "%s(%s)" % (
+self.__class__.__name__,
+", ".join("%s=%r" % (arg, getattr(self, arg, None)) for arg in self.fields),
+)
+def dump(self):
+def _dump(node):
+if not isinstance(node, Node):
+buf.append(repr(node))
+return
+buf.append("nodes.%s(" % node.__class__.__name__)
+if not node.fields:
+buf.append(")")
+return
+for idx, field in enumerate(node.fields):
+if idx:
+buf.append(", ")
+value = getattr(node, field)
+if isinstance(value, list):
+buf.append("[")
+for idx, item in enumerate(value):
+if idx:
+buf.append(", ")
+_dump(item)
+buf.append("]")
+else:
+_dump(value)
+buf.append(")")
+buf = []
+_dump(self)
+return "".join(buf)
+class Stmt(Node):
+"""Base node for all statements."""
+abstract = True
+class Helper(Node):
+"""Nodes that exist in a specific context only."""
+abstract = True
+class Template(Node):
+"""Node that represents a template.  This must be the outermost node that
+is passed to the compiler.
+"""
+fields = ("body",)
+class Output(Stmt):
+"""A node that holds multiple expressions which are then printed out.
+This is used both for the `print` statement and the regular template data.
+"""
+fields = ("nodes",)
+class Extends(Stmt):
+"""Represents an extends statement."""
+fields = ("template",)
+class For(Stmt):
+"""The for loop.  `target` is the target for the iteration (usually a
+:class:`Name` or :class:`Tuple`), `iter` the iterable.  `body` is a list
+of nodes that are used as loop-body, and `else_` a list of nodes for the
+`else` block.  If no else node exists it has to be an empty list.
+For filtered nodes an expression can be stored as `test`, otherwise `None`.
+"""
+fields = ("target", "iter", "body", "else_", "test", "recursive")
+class If(Stmt):
+"""If `test` is true, `body` is rendered, else `else_`."""
+fields = ("test", "body", "elif_", "else_")
+class Macro(Stmt):
+"""A macro definition.  `name` is the name of the macro, `args` a list of
+arguments and `defaults` a list of defaults if there are any.  `body` is
+a list of nodes for the macro body.
+"""
+fields = ("name", "args", "defaults", "body")
+class CallBlock(Stmt):
+"""Like a macro without a name but a call instead.  `call` is called with
+the unnamed macro as `caller` argument this node holds.
+"""
+fields = ("call", "args", "defaults", "body")
+class FilterBlock(Stmt):
+"""Node for filter sections."""
+fields = ("body", "filter")
+class With(Stmt):
+"""Specific node for with statements.  In older versions of Jinja the
+with statement was implemented on the base of the `Scope` node instead.
+.. versionadded:: 2.9.3
+"""
+fields = ("targets", "values", "body")
+class Block(Stmt):
+"""A node that represents a block."""
+fields = ("name", "body", "scoped")
+class Include(Stmt):
+"""A node that represents the include tag."""
+fields = ("template", "with_context", "ignore_missing")
+class Import(Stmt):
+"""A node that represents the import tag."""
+fields = ("template", "target", "with_context")
+class FromImport(Stmt):
+"""A node that represents the from import tag.  It's important to not
+pass unsafe names to the name attribute.  The compiler translates the
+attribute lookups directly into getattr calls and does *not* use the
+subscript callback of the interface.  As exported variables may not
+start with double underscores (which the parser asserts) this is not a
+problem for regular Jinja code, but if this node is used in an extension
+extra care must be taken.
+The list of names may contain tuples if aliases are wanted.
+"""
+fields = ("template", "names", "with_context")
+class ExprStmt(Stmt):
+"""A statement that evaluates an expression and discards the result."""
+fields = ("node",)
+class Assign(Stmt):
+"""Assigns an expression to a target."""
+fields = ("target", "node")
+class AssignBlock(Stmt):
+"""Assigns a block to a target."""
+fields = ("target", "filter", "body")
+class Expr(Node):
+"""Baseclass for all expressions."""
+abstract = True
+def as_const(self, eval_ctx=None):
+"""Return the value of the expression as constant or raise
+:exc:`Impossible` if this was not possible.
+An :class:`EvalContext` can be provided, if none is given
+a default context is created which requires the nodes to have
+an attached environment.
+.. versionchanged:: 2.4
+the `eval_ctx` parameter was added.
+"""
+raise Impossible()
+def can_assign(self):
+"""Check if it's possible to assign something to this node."""
+return False
+class BinExpr(Expr):
+"""Baseclass for all binary expressions."""
+fields = ("left", "right")
+operator = None
+abstract = True
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+# intercepted operators cannot be folded at compile time
+if (
+self.environment.sandboxed
+and self.operator in self.environment.intercepted_binops
+):
+raise Impossible()
+f = _binop_to_func[self.operator]
+try:
+return f(self.left.as_const(eval_ctx), self.right.as_const(eval_ctx))
+except Exception:
+raise Impossible()
+class UnaryExpr(Expr):
+"""Baseclass for all unary expressions."""
+fields = ("node",)
+operator = None
+abstract = True
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+# intercepted operators cannot be folded at compile time
+if (
+self.environment.sandboxed
+and self.operator in self.environment.intercepted_unops
+):
+raise Impossible()
+f = _uaop_to_func[self.operator]
+try:
+return f(self.node.as_const(eval_ctx))
+except Exception:
+raise Impossible()
+class Name(Expr):
+"""Looks up a name or stores a value in a name.
+The `ctx` of the node can be one of the following values:
+-   `store`: store a value in the name
+-   `load`: load that name
+-   `param`: like `store` but if the name was defined as function parameter.
+"""
+fields = ("name", "ctx")
+def can_assign(self):
+return self.name not in ("true", "false", "none", "True", "False", "None")
+class NSRef(Expr):
+"""Reference to a namespace value assignment"""
+fields = ("name", "attr")
+def can_assign(self):
+# We don't need any special checks here; NSRef assignments have a
+# runtime check to ensure the target is a namespace object which will
+# have been checked already as it is created using a normal assignment
+# which goes through a `Name` node.
+return True
+class Literal(Expr):
+"""Baseclass for literals."""
+abstract = True
+class Const(Literal):
+"""All constant values.  The parser will return this node for simple
+constants such as ``42`` or ``"foo"`` but it can be used to store more
+complex values such as lists too.  Only constants with a safe
+representation (objects where ``eval(repr(x)) == x`` is true).
+"""
+fields = ("value",)
+def as_const(self, eval_ctx=None):
+rv = self.value
+if (
+PY2
+and type(rv) is text_type
+and self.environment.policies["compiler.ascii_str"]
+):
+try:
+rv = rv.encode("ascii")
+except UnicodeError:
+pass
+return rv
+@classmethod
+def from_untrusted(cls, value, lineno=None, environment=None):
+"""Return a const object if the value is representable as
+constant value in the generated code, otherwise it will raise
+an `Impossible` exception.
+"""
+from .compiler import has_safe_repr
+if not has_safe_repr(value):
+raise Impossible()
+return cls(value, lineno=lineno, environment=environment)
+class TemplateData(Literal):
+"""A constant template string."""
+fields = ("data",)
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+if eval_ctx.volatile:
+raise Impossible()
+if eval_ctx.autoescape:
+return Markup(self.data)
+return self.data
+class Tuple(Literal):
+"""For loop unpacking and some other things like multiple arguments
+for subscripts.  Like for :class:`Name` `ctx` specifies if the tuple
+is used for loading the names or storing.
+"""
+fields = ("items", "ctx")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return tuple(x.as_const(eval_ctx) for x in self.items)
+def can_assign(self):
+for item in self.items:
+if not item.can_assign():
+return False
+return True
+class List(Literal):
+"""Any list literal such as ``[1, 2, 3]``"""
+fields = ("items",)
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return [x.as_const(eval_ctx) for x in self.items]
+class Dict(Literal):
+"""Any dict literal such as ``{1: 2, 3: 4}``.  The items must be a list of
+:class:`Pair` nodes.
+"""
+fields = ("items",)
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return dict(x.as_const(eval_ctx) for x in self.items)
+class Pair(Helper):
+"""A key, value pair for dicts."""
+fields = ("key", "value")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return self.key.as_const(eval_ctx), self.value.as_const(eval_ctx)
+class Keyword(Helper):
+"""A key, value pair for keyword arguments where key is a string."""
+fields = ("key", "value")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return self.key, self.value.as_const(eval_ctx)
+class CondExpr(Expr):
+"""A conditional expression (inline if expression).  (``{{
+foo if bar else baz }}``)
+"""
+fields = ("test", "expr1", "expr2")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+if self.test.as_const(eval_ctx):
+return self.expr1.as_const(eval_ctx)
+# if we evaluate to an undefined object, we better do that at runtime
+if self.expr2 is None:
+raise Impossible()
+return self.expr2.as_const(eval_ctx)
+def args_as_const(node, eval_ctx):
+args = [x.as_const(eval_ctx) for x in node.args]
+kwargs = dict(x.as_const(eval_ctx) for x in node.kwargs)
+if node.dyn_args is not None:
+try:
+args.extend(node.dyn_args.as_const(eval_ctx))
+except Exception:
+raise Impossible()
+if node.dyn_kwargs is not None:
+try:
+kwargs.update(node.dyn_kwargs.as_const(eval_ctx))
+except Exception:
+raise Impossible()
+return args, kwargs
+class Filter(Expr):
+"""This node applies a filter on an expression.  `name` is the name of
+the filter, the rest of the fields are the same as for :class:`Call`.
+If the `node` of a filter is `None` the contents of the last buffer are
+filtered.  Buffers are created by macros and filter blocks.
+"""
+fields = ("node", "name", "args", "kwargs", "dyn_args", "dyn_kwargs")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+if eval_ctx.volatile or self.node is None:
+raise Impossible()
+# we have to be careful here because we call filter_ below.
+# if this variable would be called filter, 2to3 would wrap the
+# call in a list because it is assuming we are talking about the
+# builtin filter function here which no longer returns a list in
+# python 3.  because of that, do not rename filter_ to filter!
+filter_ = self.environment.filters.get(self.name)
+if filter_ is None or getattr(filter_, "contextfilter", False) is True:
+raise Impossible()
+# We cannot constant handle async filters, so we need to make sure
+# to not go down this path.
+if eval_ctx.environment.is_async and getattr(
+filter_, "asyncfiltervariant", False
+):
+raise Impossible()
+args, kwargs = args_as_const(self, eval_ctx)
+args.insert(0, self.node.as_const(eval_ctx))
+if getattr(filter_, "evalcontextfilter", False) is True:
+args.insert(0, eval_ctx)
+elif getattr(filter_, "environmentfilter", False) is True:
+args.insert(0, self.environment)
+try:
+return filter_(*args, **kwargs)
+except Exception:
+raise Impossible()
+class Test(Expr):
+"""Applies a test on an expression.  `name` is the name of the test, the
+rest of the fields are the same as for :class:`Call`.
+"""
+fields = ("node", "name", "args", "kwargs", "dyn_args", "dyn_kwargs")
+def as_const(self, eval_ctx=None):
+test = self.environment.tests.get(self.name)
+if test is None:
+raise Impossible()
+eval_ctx = get_eval_context(self, eval_ctx)
+args, kwargs = args_as_const(self, eval_ctx)
+args.insert(0, self.node.as_const(eval_ctx))
+try:
+return test(*args, **kwargs)
+except Exception:
+raise Impossible()
+class Call(Expr):
+"""Calls an expression.  `args` is a list of arguments, `kwargs` a list
+of keyword arguments (list of :class:`Keyword` nodes), and `dyn_args`
+and `dyn_kwargs` has to be either `None` or a node that is used as
+node for dynamic positional (``*args``) or keyword (``**kwargs``)
+arguments.
+"""
+fields = ("node", "args", "kwargs", "dyn_args", "dyn_kwargs")
+class Getitem(Expr):
+"""Get an attribute or item from an expression and prefer the item."""
+fields = ("node", "arg", "ctx")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+if self.ctx != "load":
+raise Impossible()
+try:
+return self.environment.getitem(
+self.node.as_const(eval_ctx), self.arg.as_const(eval_ctx)
+)
+except Exception:
+raise Impossible()
+def can_assign(self):
+return False
+class Getattr(Expr):
+"""Get an attribute or item from an expression that is a ascii-only
+bytestring and prefer the attribute.
+"""
+fields = ("node", "attr", "ctx")
+def as_const(self, eval_ctx=None):
+if self.ctx != "load":
+raise Impossible()
+try:
+eval_ctx = get_eval_context(self, eval_ctx)
+return self.environment.getattr(self.node.as_const(eval_ctx), self.attr)
+except Exception:
+raise Impossible()
+def can_assign(self):
+return False
+class Slice(Expr):
+"""Represents a slice object.  This must only be used as argument for
+:class:`Subscript`.
+"""
+fields = ("start", "stop", "step")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+def const(obj):
+if obj is None:
+return None
+return obj.as_const(eval_ctx)
+return slice(const(self.start), const(self.stop), const(self.step))
+class Concat(Expr):
+"""Concatenates the list of expressions provided after converting them to
+unicode.
+"""
+fields = ("nodes",)
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return "".join(text_type(x.as_const(eval_ctx)) for x in self.nodes)
+class Compare(Expr):
+"""Compares an expression with some other expressions.  `ops` must be a
+list of :class:`Operand`\\s.
+"""
+fields = ("expr", "ops")
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+result = value = self.expr.as_const(eval_ctx)
+try:
+for op in self.ops:
+new_value = op.expr.as_const(eval_ctx)
+result = _cmpop_to_func[op.op](value, new_value)
+if not result:
+return False
+value = new_value
+except Exception:
+raise Impossible()
+return result
+class Operand(Helper):
+"""Holds an operator and an expression."""
+fields = ("op", "expr")
+if __debug__:
+Operand.__doc__ += "\nThe following operators are available: " + ", ".join(
+sorted(
+"``%s``" % x
+for x in set(_binop_to_func) | set(_uaop_to_func) | set(_cmpop_to_func)
+)
+)
+class Mul(BinExpr):
+"""Multiplies the left with the right node."""
+operator = "*"
+class Div(BinExpr):
+"""Divides the left by the right node."""
+operator = "/"
+class FloorDiv(BinExpr):
+"""Divides the left by the right node and truncates conver the
+result into an integer by truncating.
+"""
+operator = "//"
+class Add(BinExpr):
+"""Add the left to the right node."""
+operator = "+"
+class Sub(BinExpr):
+"""Subtract the right from the left node."""
+operator = "-"
+class Mod(BinExpr):
+"""Left modulo right."""
+operator = "%"
+class Pow(BinExpr):
+"""Left to the power of right."""
+operator = "**"
+class And(BinExpr):
+"""Short circuited AND."""
+operator = "and"
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return self.left.as_const(eval_ctx) and self.right.as_const(eval_ctx)
+class Or(BinExpr):
+"""Short circuited OR."""
+operator = "or"
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return self.left.as_const(eval_ctx) or self.right.as_const(eval_ctx)
+class Not(UnaryExpr):
+"""Negate the expression."""
+operator = "not"
+class Neg(UnaryExpr):
+"""Make the expression negative."""
+operator = "-"
+class Pos(UnaryExpr):
+"""Make the expression positive (noop for most expressions)"""
+operator = "+"
+# Helpers for extensions
+class EnvironmentAttribute(Expr):
+"""Loads an attribute from the environment object.  This is useful for
+extensions that want to call a callback stored on the environment.
+"""
+fields = ("name",)
+class ExtensionAttribute(Expr):
+"""Returns the attribute of an extension bound to the environment.
+The identifier is the identifier of the :class:`Extension`.
+This node is usually constructed by calling the
+:meth:`~jinja2.ext.Extension.attr` method on an extension.
+"""
+fields = ("identifier", "name")
+class ImportedName(Expr):
+"""If created with an import name the import name is returned on node
+access.  For example ``ImportedName('cgi.escape')`` returns the `escape`
+function from the cgi module on evaluation.  Imports are optimized by the
+compiler so there is no need to assign them to local variables.
+"""
+fields = ("importname",)
+class InternalName(Expr):
+"""An internal name in the compiler.  You cannot create these nodes
+yourself but the parser provides a
+:meth:`~jinja2.parser.Parser.free_identifier` method that creates
+a new identifier for you.  This identifier is not available from the
+template and is not threated specially by the compiler.
+"""
+fields = ("name",)
+def __init__(self):
+raise TypeError(
+"Can't create internal names.  Use the "
+"`free_identifier` method on a parser."
+)
+class MarkSafe(Expr):
+"""Mark the wrapped expression as safe (wrap it as `Markup`)."""
+fields = ("expr",)
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+return Markup(self.expr.as_const(eval_ctx))
+class MarkSafeIfAutoescape(Expr):
+"""Mark the wrapped expression as safe (wrap it as `Markup`) but
+only if autoescaping is active.
+.. versionadded:: 2.5
+"""
+fields = ("expr",)
+def as_const(self, eval_ctx=None):
+eval_ctx = get_eval_context(self, eval_ctx)
+if eval_ctx.volatile:
+raise Impossible()
+expr = self.expr.as_const(eval_ctx)
+if eval_ctx.autoescape:
+return Markup(expr)
+return expr
+class ContextReference(Expr):
+"""Returns the current template context.  It can be used like a
+:class:`Name` node, with a ``'load'`` ctx and will return the
+current :class:`~jinja2.runtime.Context` object.
+Here an example that assigns the current template name to a
+variable named `foo`::
+Assign(Name('foo', ctx='store'),
+Getattr(ContextReference(), 'name'))
+This is basically equivalent to using the
+:func:`~jinja2.contextfunction` decorator when using the
+high-level API, which causes a reference to the context to be passed
+as the first argument to a function.
+"""
+class DerivedContextReference(Expr):
+"""Return the current template context including locals. Behaves
+exactly like :class:`ContextReference`, but includes local
+variables, such as from a ``for`` loop.
+.. versionadded:: 2.11
+"""
+class Continue(Stmt):
+"""Continue a loop."""
+class Break(Stmt):
+"""Break a loop."""
+class Scope(Stmt):
+"""An artificial scope."""
+fields = ("body",)
+class OverlayScope(Stmt):
+"""An overlay scope for extensions.  This is a largely unoptimized scope
+that however can be used to introduce completely arbitrary variables into
+a sub scope from a dictionary or dictionary like object.  The `context`
+field has to evaluate to a dictionary object.
+Example usage::
+OverlayScope(context=self.call_method('get_context'),
+body=[...])
+.. versionadded:: 2.10
+"""
+fields = ("context", "body")
+class EvalContextModifier(Stmt):
+"""Modifies the eval context.  For each option that should be modified,
+a :class:`Keyword` has to be added to the :attr:`options` list.
+Example to change the `autoescape` setting::
+EvalContextModifier(options=[Keyword('autoescape', Const(True))])
+"""
+fields = ("options",)
+class ScopedEvalContextModifier(EvalContextModifier):
+"""Modifies the eval context and reverts it later.  Works exactly like
+:class:`EvalContextModifier` but will only modify the
+:class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
+"""
+fields = ("body",)
+# make sure nobody creates custom nodes
+def _failing_new(*args, **kwargs):
+raise TypeError("can't create custom node types")
+NodeType.__new__ = staticmethod(_failing_new)
+del _failing_new

Mercurial > repos > guerler > springsuite

comparison planemo/lib/python3.7/site-packages/jinja2/nodes.py @ 1:56ad4e20f292 draft