File base.py has 888 lines of code (exceeds 250 allowed). Consider refactoring.

Open

"""
This is the Django template system.

How it works:

Function _resolve_lookup has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring.

Open

    def _resolve_lookup(self, context):
        """
        Perform resolution of a real variable (i.e. not a literal) against the
        given context.

• Read up
  Read up

Function resolve has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.

Open

    def resolve(self, context, ignore_failures=False):
        if self.is_var:
            try:
                obj = self.var.resolve(context)
            except VariableDoesNotExist:

• Read up
  Read up

Function parse has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.

Open

    def parse(self, parse_until=None):
        """
        Iterate through the parser tokens and compiles each one into a node.

        If parse_until is provided, parsing will stop once one of the

• Read up
  Read up

Function token_kwargs has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.

Open

def token_kwargs(bits, parser, support_legacy=False):
    """
    Parse token keyword arguments and return a dictionary of the arguments
    retrieved from the ``bits`` token list.

• Read up
  Read up

Function __init__ has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def __init__(self, token, parser):
        self.token = token
        matches = filter_re.finditer(token)
        var_obj = None
        filters = []

• Read up
  Read up

Function create_token has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def create_token(self, token_string, position, lineno, in_tag):
        """
        Convert the given token string into a new Token object and return it.
        If in_tag is True, we are processing something that matched a tag,
        otherwise it should be treated as a literal string.

• Read up
  Read up

Function __init__ has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def __init__(self, var):
        self.var = var
        self.literal = None
        self.lookups = None
        self.translate = False

• Read up
  Read up

Function render_annotated has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    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

• Read up
  Read up

Function resolve has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def resolve(self, context):
        """Resolve this variable against a given context."""
        if self.lookups is not None:
            # We're dealing with a variable that needs to be resolved
            value = self._resolve_lookup(context)

• Read up
  Read up

Avoid too many return statements within this function.

Open

    return kwargs

Avoid too many return statements within this function.

Open

        return Token(TokenType.TEXT, token_string, position, lineno)

Avoid too many return statements within this function.

Open

                return kwargs

Avoid too many return statements within this function.

Open

                return kwargs

Function split_contents has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def split_contents(self):
        split = []
        bits = smart_split(self.contents)
        for bit in bits:
            # Handle translation-marked template pieces

• Read up
  Read up