class DebugNode

from django.template.defaulttags import DebugNode 


  

    
Ancestors (MRO)

    
    
      
      
  1. builtins.object
    2. 
      
      
  2. django.template.base.Node
    3. 
      
      
  3. django.template.defaulttags.DebugNode
    4. 
      
    

  


  

  
    

      

        
Fields

        

          


        

      

      

        
          
AttributeTypeDefined in

        
        
          
            
              
                
              
            
          
            
              
                
              
            
          
        
      

    

  

  
    

      

        
Attributes

        

          


        

      

      

        
          
AttributeValueDefined in

        
        
          
            
              
                
              
            
          
            
              
                
              
            
          
            
              
                
              
            
          
        
      

    

  

  
    

      

        
Methods

        

          


        

      

      
        
          

            

              
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 render(self, context)

              

                django.template.defaulttags.DebugNode
              

            

            

              
                
                  

                    

                      django.template.defaulttags.DebugNode
                    

                    

                

                      
                        
Return the node rendered as a string.

                      

                      
                        
    def render(self, context):
        if not settings.DEBUG:
            return ""

        from pprint import pformat

        output = [escape(pformat(val)) for val in context]
        output.append("\n\n")
        output.append(escape(pformat(sys.modules)))
        return "".join(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