class SimpleNode

from yak.tags import SimpleNode 
Django SimpleNode subclass that supports context assignment through
AssignmentNodeMixin

Ancestors (MRO)

  1. builtins.object
  2. django.template.base.Node
  3. django.template.library.TagHelperNode
  4. django.template.library.SimpleNode
  5. yak.tags.AssignmentNodeMixin
  6. yak.tags.SimpleNode

Fields

AttributeTypeDefined in

Attributes

AttributeValueDefined in

Methods

def __init__(self, func, takes_context, args, kwargs, target_var)
django.template.library.SimpleNode
django.template.library.SimpleNode 
Initialize self.  See help(type(self)) for accurate signature.
    def __init__(self, func, takes_context, args, kwargs, target_var):
        super().__init__(func, takes_context, args, kwargs)
        self.target_var = target_var
django.template.library.TagHelperNode 
Initialize self.  See help(type(self)) for accurate signature.
    def __init__(self, func, takes_context, args, kwargs):
        self.func = func
        self.takes_context = takes_context
        self.args = args
        self.kwargs = kwargs

def get_nodes_by_type(self, nodetype)
django.template.base.Node 
Return a list of all nodes (within this node and its nodelist)
of the given type
    def get_nodes_by_type(self, nodetype):
        """
        Return a list of all nodes (within this node and its nodelist)
        of the given type
        """
        nodes = []
        if isinstance(self, nodetype):
            nodes.append(self)
        for attr in self.child_nodelists:
            nodelist = getattr(self, attr, None)
            if nodelist:
                nodes.extend(nodelist.get_nodes_by_type(nodetype))
        return nodes

def get_resolved_arguments(self, context)
django.template.library.TagHelperNode 
    def get_resolved_arguments(self, context):
        resolved_args = [var.resolve(context) for var in self.args]
        if self.takes_context:
            resolved_args = [context] + resolved_args
        resolved_kwargs = {k: v.resolve(context) for k, v in self.kwargs.items()}
        return resolved_args, resolved_kwargs

def render(self, context)
yak.tags.AssignmentNodeMixin
yak.tags.AssignmentNodeMixin 
Return the node rendered as a string.
    def render(self, context):
        rendered = super().render(context)
        if self.template_tag and self.template_tag.target_var:
            context[self.template_tag.target_var] = rendered
            return ''
        return rendered
django.template.library.SimpleNode 
Return the node rendered as a string.
    def render(self, context):
        resolved_args, resolved_kwargs = self.get_resolved_arguments(context)
        output = self.func(*resolved_args, **resolved_kwargs)
        if self.target_var is not None:
            context[self.target_var] = output
            return ""
        if context.autoescape:
            output = conditional_escape(output)
        return output
django.template.base.Node 
Return the node rendered as a string.
    def render(self, context):
        """
        Return the node rendered as a string.
        """
        pass

def render_annotated(self, context)
django.template.base.Node 
Render the node. If debug is True and an exception occurs during
rendering, the exception is annotated with contextual line information
where it occurred in the template. For internal usage this method is
preferred over using the render method directly.
    def render_annotated(self, context):
        """
        Render the node. If debug is True and an exception occurs during
        rendering, the exception is annotated with contextual line information
        where it occurred in the template. For internal usage this method is
        preferred over using the render method directly.
        """
        try:
            return self.render(context)
        except Exception as e:
            if context.template.engine.debug:
                # Store the actual node that caused the exception.
                if not hasattr(e, "_culprit_node"):
                    e._culprit_node = self
                if (
                    not hasattr(e, "template_debug")
                    and context.render_context.template.origin == e._culprit_node.origin
                ):
                    e.template_debug = (
                        context.render_context.template.get_exception_info(
                            e,
                            e._culprit_node.token,
                        )
                    )
            raise