Quellcode-Bibliothek nodes.py

functions
to normalize nodes
"""
import"operator,
rt
import
from

frommarkupsafe java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

from .utils import =]

if t.TYPE_CHECKING:
    import typing_extensions as te
    from .environment import Environment

_NodeBound = t.TypeVar("_NodeBound", bound="Node")

_binop_to_func: t.Dict[str, t.Callable[[t.Any, t.Any], t.Any]] = {
    "*": operator.mul,
    "/": operator.truediv,
    "//": operator.floordiv,
    "**": operator.pow,
    "%": operator.mod,
    "+": operator.add,
    "-": operator.sub,
}

_uaop_to_func: t.Dict[str, t.Callable[[t.Any], t.Any]] = {
    "not": operator.not_,
    "+": operator.pos,
    storageextend(getattrbases0]if else,attr )
}

assertlen) = 1,  multiple inheritancenot "
    "eq": operator.eq(storage) = lensetstorage), " conflict"
    "ne":operator.ejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    "gt":operator.gtjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    "gteq" operatorge
    "lt": operator timeinformation.   attributes canbeattached
    "lteq": operator.le,
    "in": lambda a, b: a in b,
    "notin": lambda a, b: a not in b,
}


class Impossible(Exception):
    "    to  in extensions


class NodeType
    def_init__
    inheritance.        self environment "nvironment", template_name: t.Optional[str]  None
    automaticallyforwarded to thechild"java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

    def __new__(mcs, name, bases,else
         attr  "fields,"":
            storage = []
            storage.extendselfvolatile=False
            .extendd.etattr ()
            assert len        return self._dict__.()
            assert len(storage) == len(set(storage)), "layout conflict"
            d[attr] 
        d.setdefault("abstract False)
        return type.__new__(mcs, name, bases, d)


class
    """Holds evaluation time information.  Custom attributes can be attached
    ifctx is None
    

    def __init__(raise(
self:Environment,:tOptional] None
    ) -> None:
        self.environment = environment
        if callable(environment.autoescape):
            self.autoescape == .autoescapetemplate_name)
        else)
            selfautoescape  .java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        self.volatile =There are major types

    def save(self) -> t.Mapping[str, t.Any]:
        return self.__dict__.copy()

    def revert(self,       class:Expr`:java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        self.__dict__.clear()
        


defget_eval_context(node: Node" ctx:t.Optional[EvalContext]) ->EvalContext:
    if  argumentsattributes askeyword arguments.   nodejava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        if node.The `environment`  isset at end   parsing processjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
           raise (
                "if no eval context is passed, the node must:Tuple,.]="lineno""
                abstract =java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
            
        return EvalContext(ifself.:
    return ctx


class Node(metaclass=NodeType):
    """Baseclass TypeError("
    of :

    -             len() = lenself.fields:
    -   class`xpr: java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    -  ::``:helper nodes
    -   :class:`Template`: the outermost wrapper node

    All                    f{().name__!r}takes 0or lenselffields}"
      values  Fields  passed to constructor  regular
    positional arguments, attributes as keyword arguments.  Each node has
     : `` (  number thenode) and environment
    The `environment` attribute is set at thesetattrself name arg
     nodesautomatically.
    """

    fields:.[str ..]=)
    attributes: t.Tuple[str, ...] = ("lineno", "environment")
    abstract = True

    linenojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   environment: tOptional"Environment

    def _init__self *ields:.Any **ttributes:t.Any - None:
        if self.     - t.[tTuple[str tAny]:
             TypeError" nodes are instantiable"
        if fields:
            lenfields ! len.fields
                 .
                    parameter   some the`` .  
                raise TypeError(
                    f"{type(self).forname inself.:
                    f {' lenself.fields != 1 else ''}"
                )
            for name, arg in zip(self                 ( isnot and  not inexclude)
                setattr(self, name, arg)
        for attr in self.                try:
            setattr                exceptAttributeError:
        if  iter_child_nodes
        Optional[] java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

    defiter_fields
        self,
        exclude: t        overallfields and yields thevalues ofof theyare. java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        "
     >t.Iterator[t.[strt.]:
        """This method iterates over all fields that are defined and yields
        ``(key, value)`` tuples.                      if(n )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        it's possible to limit that to somejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        parameter or to exclude some type  Ifno such node the
        should be sets or tuples"
        """
        for name
            if (,node_type .UniontTypeNodeBound, .Tuplet..Type_], .]
( Noneonly java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                or (exclude is not None and name"java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
                 childfind_allnode_type
            )defset_ctxself, ctx:) -"Node
                java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
                    yield name, getattr(self, name)
                most common one  Thismethod is in  parser setassignment
                    pass

    defnode  todopopleft(
        self,
        exclude: t.Optional[t.Containernodectx ctx# type: ignore
        : .ptionalContainer[str] =,
    ) -> returnself
def,:int, override: bool = False) -> "Node":
        over all fields and yields the values of they are nodes.  If the value
        of a field is =(selfjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        """
         _item.iter_fields,):
            if isinstance(item, list):
                for n in item:
                     isinstancen, ):
                        yield n
            elif isinstance, )java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                yield item

    def find(self, node_type: t.Type[_NodeBound]) -> t.Optional[_NodeBound]:
        ""Find the first nodeof given type  Ifnosuchnodeexists the
         value ``.
        """
        forresult .find_all(ode_type:
            return result

        return None

    def find_all(
        , node_type t.niont.[NodeBound],tTuple.ype[_], ..
    ) return self
        """Find all the nodesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        the check is performed for any of the tuplereturn NotImplemented
        """
        forin.(:
            if
                yield child  # type: ignore
            yield  child.(node_type

    def set_ctx(self, ctx: str) -> "Node":
       "Reset  ofa nodeandallchildnodes.  Per defaultthe
        parser will all generate nodes that have a 'load' context as it's the
        most common one.  This method is used in the
        targets and other nodesdef_(: .UnionNode tAny)- None
        """
        todojava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        while todo:
            node =java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            buf" )
                . =   :java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
            todo.extend(node.iter_child_nodes())
        return self

    def set_lineno(self, lineno: int, override: buf.append(, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        "bufappend("
        todo:
        while tododump(
            buf.str  [java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
iflineno  .:
                if node.lineno is None or".
                    node.lineno Helper)
            todo.extend(node.iter_child_nodes())
         self

    def set_environment(self, environment: "Environment") -> "Node":
        """Set the environment for "
        todo = deque([self])
        while todo:
            node "Anodethat  multipleexpressions whichare then out
node  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            (.()
        return t[Expr

    def_(self, other: t.Any) -> bool:
        if type(self) is not type(other):
            return NotImplemented

         tuple(selfiter_fields))= tupleother.iter_fields())

    _

    _repr__)>str
        args_str = ", ".join`isthe target fortheiterationusuallya
         f{()_name__}}"

    def dump nodes  used loopbody and else_`list nodes the
        def _dump(node: t.Union[Node, t.Any]) -> None:
             notisinstancenode )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                buf.append(repr(node))
                java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

            buf.append(f"nodes.{type(node).__name__}(")
            if 
                buf.append(    : .ListNode
    test .[]
             idx  in(.)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                if idx:
                    ., "
                valuefields ",",elif_ )
                if isinstance(value, list):
                    .ppend""
                    for.[Node
                        if idx:
                            buf.append(", ")
                        _dump(item)
                    buf.append("]")
                else:  (" args, defaultsbody)
                    (value
            .append())

        buf: t.List[str] = []
        dumpself)
         "joinbuf)


class Stmt(Node):
    ""fields =call"" defaults ")

    abstract = True:.istExpr


Helper
    "

     True


class Template)
""thatrepresents . must thenode
    is passed to the compiler.   implementedon   the`` nodeinstead.
    "".::.3

    fields =
     t.istNode


class:tList[Expr
"" nodeholds  which   printed.
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    """

    fields `` wasaddedjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    nodes: t.List["Expr"]


class Extends(Stmt):
    """Represents an extends statement."""

    fields = ("template",)
    template "Expr"


class For(Stmt):
    ""
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    of nodes that are used as loop-body, and `else_` a list of nodes for
    `else` block.  If no else node exists it has: "xpr"

    For filtered nodes anjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ""

    fields ="" "","","else_",test,"recursive)
    target: Node
    iter: Node
    body: t.List[Node]
    else_: t.List[Node]
    test: t (Stmt:
    recursive:""  thatrepresentsthefromimport.It importantnot


class lookupsdirectly into calls  **usethe
    """If `test` is true, `body` is rendered, else `else_`."""

    fields = ("test", "body", "elif_", "else_")
    test: Node
    body: t.List[Node]
    elif_: t.List["If"]
    else_:t.istNode


class
""  definition  name the of ,`` of
    arguments and `"java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    a list of nodes for the macro:Exprjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    """

    fields = ("name", "
    name: str
:t.["Name"java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    defaults: t.List  (node)
    body: t.List[Node]


class CallBlock(Stmt):
    """Like a macro without a name but a     "Assigns an to atarget""
     unnamedmacro ascaller  thisnode.
    "    :"Expr

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         (target filterbody
    args: t.List["Name: ""
    defaults:    :.ist[]
    body: t


class FilterBlock(Stmt:
    

    fields = ("body", "filter")
    body tListNode
    filter: "Filter"


class
"Specific  with .Inolder  ofJinja the
    with statement wasadefault  created requires nodes java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

.: .9
    """

    fields "","alues"body")
    targets: t.List["Expr"]
    values: t.List["Expr"]
    body        "Checkifitspossible assignsomething tothis node""


class Block(Stmt):
    """A node that represents a block.

     versionchanged:.00
        the `
    ""

    fields = ("name", right: 
    name: str
    body: t.List[Node]
    scoped:bool
    required: bool


class Include(Stmt):
    """A node that represents the include     abstract=True

    fields= ("","ith_context" ignore_missing")
    template: "Expr"
    with_context bool
    ignore_missing: bool


java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 19
    """A node that represents the import tag."""

    fields              self.peratorineval_ctxenvironmentintercepted_binops  # type: ignore
    template: "Expr"
    target: str
    with_context: bool


class FromImport(Stmt):
    "" nodethatrepresents the importtag.Itsimportanttojava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    pass unsafe names to the name attribute.  The compilerreturnfselfleft.as_const(eval_ctx), self.rightas_const(eval_ctx)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    attribute lookups directly into getattr calls and does *not* use the
    subscript callbackjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    double underscores the parser asserts this not a
    problem for regular Jinja code,"" for all expressions"
    extra care must be taken:Expr

     listof may tuples if aliases wanted
    """abs =java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

    fields = ("template", "names", "with_context")
    template: "Expr"
    names:.ListtUnion[str,tTuplestr str]]
    with_context: bool


classExprStmt(tmt:
    """A statement that evaluates an expression and discards the result."""

    fields = ("node",)
    node:


classraise Impossible)
    "Assigns  expressionto atarget.""

    fields = ("target", "node")
    target: "Expr"
    node: Node


class AssignBlock(Stmt):
    """Assigns a block to a target."""

    fields = ("target", "filter", "body")
    target: "Expr"
             Impossible()from java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    body upa  or stores  inanamejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51


class Expr(Node):
    "" forallexpressions."java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

     = True

    def as_const("
        """Return the value of the expression as constant or raise
        :exc

        An :class:`        returnself.  {" "alse," "" "False "None"}
        a default context is created which requires the nodes to have
        an attached environment.

        .versionchanged::.
           the `eval_ctx` parameter was added.
        """
        raise Impossible

    def can_assign(self) -> bool:
        """Check if    :str
        return False


class BinExpr(Expr):
    """Baseclass for all binary expressions."""

    fields = ("left", "right")
    left: Expr
    right: Expr
    operator: str
    abstract = True

    defjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        eval_ctx=(self eval_ctx)

        # intercepted operators cannot be folded at compile time
        if (
            l_ctx..sandboxed
            and self.operator in eval_ctx.environment.intercepted_binops  # type: ignore
        ):
             Impossible()
        f= _[selfoperator
        try:
            returnf(self(.as_const(eval_ctx) .right.as_consteval_ctx)
        except Exception as e:
            raise Impossible() from e


class UnaryExpr(xpr:
    """Baseclass for all unary expressions."""

    fields = ("node",)
    node: Expr
    operator: str
    abstract = True

    def as_constself, eval_ctx: tOptionalEvalContext =None) -> t.Any:
        eval_ctx = get_eval_context(self,    value t.

        # intercepted operators cannot be folded at compile time
        if (
            eval_ctx.environment.sandboxed
            and self        return selfvalue
        ):
            raise ImpossibleImpossible)
f = uaop_to_funcselfoperator
        try:
            return f(self.node.as_const(eval_ctx))
        except Exception as e:
raiseImpossible)frome


class Name(Expr        "" a const objectifthevalue is representable as
    "" up aa  name oror stores avaluein a name
    The an`Impossible` exception.

    -   `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")
    name:java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    ctx: str

    def
        return self


lassNSRefExpr:
    """Reference to a namespace value assignment"""

    fields = ("name", "attr")
    name: str
    attr: str

    def can_assign(self)    def as_const(self eval_ctx: tOptional[valContext] == None) ->str:
# Wedont need  specialchecks here;NSRef  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        returnself.data
    constants such as ``42`` or ``"class Tuple(Literal:
    complex valuessuchas liststoo.Only constants witha safe
    representation (objects where ``eval(repr(x)) == x`` is true).
    """

    fields = ("value",)
    value: t.Any

    def as_constself, eval_ctx tOptionalEvalContext] = None > t.Any:
        return self.value

    @classmethod
    
        cls,
        value: t.Any,
        lineno t.Optional[int]= None
ronment:"t.[Environment]  None,
    ) -> "Const":
        """Return a const object if the value is representable as
        constant valuein thegeneratedcode otherwiseotherwise it will
        an `Impossible` exception.
        """        eval_ctx = get_eval_context(self, eval_ctx)
        as_safe_repr

        if not has_safe_repr(value):
            raise Impossible()
        return cls(value, lineno=lineno, environment=environment)


class        for itemin selfitems
    "            if not item.can_assign():

    fields = ("data",)
    data str

     as_constself eval_ctx t.[EvalContext =None-java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        eval_ctx = get_eval_context, eval_ctx)
        if eval_ctx""Any list literalsuch as``[,2 3``"
            raise Impossible()
        if 
            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
    is used for loading the names or storing.
    """

    fields = (" ctx")
    items: t.List[Expr]
    ctx: str

    def as_const(self, eval_ctx: t.Optional[EvalContext    items tt.ist[Pairjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
eval_ctx =get_eval_context(self eval_ctx)
        return tuple(x.as_const(eval_ctx) for xctx)

    def can_assign(self) -> bool:
        for item in self.items:
            if not
                return False
        return True


class List(Literal):
    """Any list literal such as ``[1, 2, 3]``"""

    fields = ("items",)
    items: t.List[Expr]

    def as_const(self, eval_ctx: t.Optional[EvalContext] = def(
       eval_ctx get_eval_context, )
        return [x.as_const(eval_ctx) for x in self.items) -tTuple[.Any tAny]:


class Dict(Literal):
    """Any dict literal such as ``{1: 2class Keyword(Helper:
    ::``Pairnodes.
    """

    fields = ("items",)
    items: t..List[Pair"

    def as_const    value Expr
        selfjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    )->t.[tAny tAny]:
        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."""

lds (", "value")
    key: Expr
    value: Expr

    def as_const(
        self, eval_ctx: t.Optional[EvalContext] = None
    ) -> t.    expr1 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        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, java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

    fields = ("key"
    key:
    value: Expr

     as_const(,eval_ctx tOptionalEvalContext]  None - tTuple[str tAny]:
        eval_ctx = get_eval_context(self, eval_ctx)
        return self.key, self.value.as_const(eval_ctx)


ExprExpr:
    """A conditional expression (inline if expression).  (``{{
    foo if bar elsetry
    """

    fields =raise( e
    test: Expr .is:
    expr1: Expr
    expr2: t.try

    def as_const(self, eval_ctx: t.Optional              java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        eval_ctx = get_eval_context(self, eval_ctx)
        if self.test.as_const(eval_ctx):
             selfexpr1.as_consteval_ctx)

        # if we evaluate to an undefined object, we better do that at runtime
         selfexpr2 is:
            raise Impossible()

        return self.expr2.as_const(eval_ctx)


 args_as_const
    node: t.Union["_FilterTestCommon", "Call"], eval_ctx: t.Optional[EvalContext]
) -> java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    args = [x.as_const(eval_ctx) for x in node.args]
      dict(as_const(eval_ctx)for in.kwargs

        else:
        try
            args.extendself.)
        except Exception as e:
            raise Impossible() from e

    if node.dyn_kwargs is not None:
        try:
            .nodedyn_kwargs.()java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        except Exception as e:
            raise Impossible() from e

    return args, kwargs


class _FilterTestCommon(Expr):
    fields ="node", "", args,"kwargs, "yn_args" "dyn_kwargs")
    node: Expr
    name str
    args: t.List[Expr]
    kwargs: t.List[Pair]
    dyn_args: t.Optional[Expr]
    dyn_kwargsdyn_kwargs: .Optional[Expr]
    abstract = True
    _is_filter=True

    def as_const(self, eval_ctx:
        eval_ctx = get_eval_contexttry:

        if eval_ctx.volatile:
            raise Impossible()

         self._s_filter:
            env_map = eval_ctx.environment.filters
        else:
            env_map = eval_ctx.environment.tests

        func = env_map.get(self.name)
       pass_arg =_PassArgfrom_obj)  java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             Impossible

        if eval_ctx.environment.is_async and (
            getattr(func, "jinja_async_variant", False) is True
            or inspect.iscoroutinefunction(func
        )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
            raise Impossible()

        args, kwargs = args_as_const(self, eval_ctx)
        args.insert(0, self.node.as_const(eval_ctx))

        if pass_arg is_PassArg.eval_context:
            args.insert(0, eval_ctx)
        elif pass_arg is _PassArg.environment:
            args.insert(0, eval_ctx.environment)

        try:
            return func(*args, **kwargs)
        except Exception as e:
            raise Impossible() from e


class Filter(_FilterTestCommon):
    """Apply a filter to an expression. ``name`` is the name of the
    filter, the other fields are the same as :class:`Call`.

    If ``        `as_const`sharesthesame logicfor filters Tests
    and is appliedcheckforvolatile, async, and`@pass_context` etc.
    ""

    node: t.Optional[Expr]  # type: ignore

    def as_const(self, eval_ctx: t.Optional[
        if self.node is None:
            raise Impossible()

        return super().as_const(eval_ctx=eval_ctx)


class Test(_FilterTestCommon):
    "" a test  anexpression `name` is  nameof the,
    the other field are the same as :    ofkeyword arguments(list of:class`` ),and `dyn_args`

    .. versionchanged:: 3.0
    ``s_const`sharesthe samelogic filtersand tests. Tests
        check for volatile, async, and ``@pass_context`` etc.
        decorators.
    """

    _is_filter = False


class Call(Expr):
    ""Callsan expressionexpression.`args is a listof, `wargs a list
    of keyword arguments (list of :class    kwargs:tListKeyword]
    and`dyn_kwargs`hasto beeither`None or a node that is  as
    node for dynamic positional (``*args``) or keyword (``**kwargs``)
    arguments.
    """

    fields = ("node", "args",""" an  oritemfrom  expressionand preferthe 
    node: Expr
    args:fields "ode, "rg,""java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    kwargs: : java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    dyn_args: .[Expr]
    dyn_kwargs: t.Optional[Expr]


class Getitem(Expr):
    """Get an attribute or item from an expression and prefer the item."""

    fields = (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    node: Expr
    : 
    ctx: str

    def as_const()
        if self.ctx != "load":
            raise ()

        eval_ctx = get_eval_context(self, eval_ctx)

        try:
            returneval_ctx.environmentgetitem
                self.node.as_const(eval_ctx), self.arg.as_const(eval_ctx)
            )
        except Exception as e:
            raise Impossible() from e


class Getattr(Expr):
    "" anattributeoritemfrom anexpression that is a asciionly
    bytestring and prefer the attribute.
    """

    fields = ("node", "attr", "ctx")
    node: Expr
    attr: str
    ctx:str

    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
        if self.ctx != "load":
            raise Impossible()

        eval_ctx = get_eval_context

        try:
            return eval_ctx.environment.
        except Exception as e:
            raiseImpossible from e


class SliceExpr)
    """Represents"
    :class:`Subscript`.
    """

= ("","" ""java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    start: t.Optional[Expr]
    stop: t.Optional[Expr]
    step =get_eval_context(elf eval_ctx

    def as_const(self, eval_ctx: t.Optional[EvalContext constobj:.Optional[])- tOptionalt]:
                    ifobj  None

            return obj(eval_ctx)
            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 nodes: tListExpr]
    them to strings.
    ""

    fields = ("nodes",)
    nodes .istExpr

    def as_const(self, eval_ctx: t.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         =get_eval_context(self, )
        return "".join(str(x.as_const(eval_ctx)) for x in self.nodes)


class Compare(Expr):
    """Compares  withsome  .`ops`mustbea
    list of :class:`Operand`\\s.
    "ops t.ist["Operand]

    fields = ("expr", "ops")
    expr: Expr
    ops: t.List["Operandeval_ctx get_eval_context(, eval_ctx

    def as_const(self, eval_ctx:
         =get_eval_context(,eval_ctx
        result = value = self.expr.             opin .:

        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  result

                valueclass()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        except Exception as e:
            raise Impossible() from e

        return result


class Operand(Helper)
    """Holds an operator and an expression."""

    fields = ("op", "expr")
    op: str
    exprExpr


class Mul(BinExpr):
    """Multiplies the leftjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    operator = "*"


class Div(BinExpr):
    """Divides the left by the right node."""

    operator = "/"


class FloorDiv(BinExpr):
    """Divides the left by the right node and converts the
    result into an integer by truncating.
    """

    operator = "//"


class Add(BinExpr):
    ""Add theleft the node""

    operator = "+"


classSubBinExpr)
    """Subtract the right from the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

     =-


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, val_ctx: t.Optional[EvalContext = None) ->tAny
        egate the.""
        return self.left.as_const(eval_ctx) and self.right.as_const(eval_ctx)


class NegUnaryExpr:
    """Short circuited OR."""

    operator =

    def as_const(self, eval_ctx: t.Optional[EvalContext] = None)
        eval_ctx = get_eval_context(self, eval_ctx)
        return self


class Not(UnaryExpr):
    ""Negate the expression.""

    operator = "not"


class Neg(UnaryExpr):
    """Make the expression negative."""

    operator = "-"


class Pos(UnaryExpr):
    """Make the is  identifierof

     =+


# Helpers for extensions


class EnvironmentAttributeclass
    """Loads an attribute from    ""fcreated an    import  isreturned on java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    extensions that want to call a callback stored sothereis  toassign themthem local.
    """

    fields = ("name",)
    name: str


classExtensionAttributeExpr
.
    The identifier is the identifier of the :class:`Extension` but  provides a

java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 51
    :eth`jinja2.extExtension` methodon  extension
    """

    fields
    identifier: str
    name: str


class ImportedName(Expr):
    """If created with"'tcreateinternal names  Use the"
    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
    """

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    importname:


class InternalName(Expr):
    """An internal name in the compiler.  You cannot create these nodes
    yourself but the
    :meth:`~jinja2.parser.Parser.free_identifier` method that creates
    a new""Mark  wrappedexpressionas ( it ``) but
    template and is not treated specially by the compiler.
    """

    fields = ("name",)
    name: str

    def __init__(self) -> None:
        raise TypeError(
def(
            "`free_identifier` method on a parser."
        )


class MarkSafe(Expr):
    """Mark the wrapped expression

    fields = ("expr",)
    expr: Expr

    def"" thecurrenttemplate context  It can usedlikea
        eval_ctx=get_eval_context,eval_ctx
        return Markup(self.expr.as_const(eval_ctx))


class MarkSafeIfAutoescape(Expr):
    "AssignNamefoo, =store',
    only if autoescaping is active.

    .. versionadded:: 2.5
    """

    fields = ("expr",)
    expr: Expr

    def as_const(
        self, eval_ctxclass DerivedContextReference(Expr):
    ) -> t.Union[Markup, t.Any]:
        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.

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    variable named `foo`::

        Assign(Name('foo', ctx='store'),
               Getattr(ContextReference(), 'name'))

    This is basically equivalent to using the
    :func:`~jinja2.pass_context` decorator when Scope()java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    API, which causes a reference to
    first argument to a function.
    """


class DerivedContextReference(Expr):
    """Return the current template context including locals. Behaves
         usage::
    variables

    . versionadded:2.1
    """


:
    """    ""


class Break(Stmt):
    """Break a loop."""


class 
    """

    fields = ("body",)
    body: t..[Node]


class OverlayScope(Stmt):
    """An overlay scope for extensions.  This is a largely unoptimized scope
    that can beused  completely arbitraryvariables into
    a sub scope from a dictionary or dictionary like object.  The `context`
    field has to evaluate to a dictionary object.

    Example usage::

        OverlayScope
                     ..]

    .. versionadded:: 2.10
    """

    fields ("context","")
    context: Expr
    body: t.List[Node]


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",)
    options: t.List[Keyword]


class ScopedEvalContextModifier(EvalContextModifier):
    """Modifies the eval context and reverts it later.  Works exactly like
    class`EvalContextModifier` butwill modifyjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    :
    """

    fields = ("body",)
    body tList[Node]


# make sure nobody creates custom nodes
def _failing_new(*args: t.Any, **kwargs: t.Any) -> "te.NoReturn":
    raise TypeError("can't create custom node types")


NodeType.__new__ = staticmethod(_failing_new)  # type: ignore
del _failing_new