Use of assert detected. The enclosed code will be removed when compiling to optimised byte code.

Open

        assert 0

• Exclude checks
  • Disable engine
  • Disable check

Use of assert detected. The enclosed code will be removed when compiling to optimised byte code.

Open

        assert sym is not None
        #
        #  Compute \epsilon-kernel state's core and see if
        #  it exists already.
        #

• Exclude checks
  • Disable engine
  • Disable check

File spark.py has 580 lines of code (exceeds 250 allowed). Consider refactoring.

Open

#  Copyright (c) 1998-2002 John Aycock
#
#  Permission is hereby granted, free of charge, to any person obtaining
#  a copy of this software and associated documentation files (the
#  "Software"), to deal in the Software without restriction, including

Function makeSet_fast has a Cognitive Complexity of 61 (exceeds 5 allowed). Consider refactoring.

Open

    def makeSet_fast(self, token, sets, i):
        #
        #  Call *only* when the entire state machine has been built!
        #  It relies on self.edges being filled in completely, and
        #  then duplicates and inlines code to boost speed at the

• Read up
  Read up

Function makeState has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.

Open

    def makeState(self, state, sym):
        assert sym is not None
        #
        #  Compute \epsilon-kernel state's core and see if
        #  it exists already.

• Read up
  Read up

Function makeSet has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.

Open

    def makeSet(self, token, sets, i):
        cur, next_item = sets[i], sets[i + 1]

        ttype = (  # pylint: disable=R1709
            token is not None and self.typestring(token) or None

• Read up
  Read up

Function computeNull has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

    def computeNull(self):
        self.nullable = {}  # pylint: disable=W0201
        tbd = []

        for rulelist in self.rules.values():

• Read up
  Read up

GenericParser has 29 functions (exceeds 20 allowed). Consider refactoring.

Open

class GenericParser:
    #
    #  An Earley parser, as per J. Earley, "An Efficient Context-Free
    #  Parsing Algorithm", CACM 13(2), pp. 94-102.  Also J. C. Earley,
    #  "An Efficient Context-Free Parsing Algorithm", Ph.D. thesis,

Function makeNewRules has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    def makeNewRules(self):
        worklist = []
        for rulelist in self.rules.values():
            for rule in rulelist:
                worklist.append((rule, 0, 1, rule))

• Read up
  Read up

Function buildTree has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def buildTree(self, nt, item, tokens, k):
        state, _ = item

        choices = []
        for rule in self.states[state].complete:

• Read up
  Read up

Function __getstate__ has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def __getstate__(self):
        if self.ruleschanged:
            #
            #  FIX ME - duplicated from parse()
            #

• Read up
  Read up

Function addRule has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def addRule(self, doc, func, _preprocess=1):
        fn = func
        rules = doc.split()

        index = []

• Read up
  Read up

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

Open

    def parse(self, tokens):
        sets = [[(1, 0), (2, 0)]]
        self.links = {}  # pylint: disable=W0201

        if self.ruleschanged:

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if new not in next_item:
                            next_item.append(new)
                        # INLINED --^
            else:

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

Open

    def tokenize(self, s):
        pos = 0
        n = len(s)
        while pos < n:
            m = self.re.match(s, pos)

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        for prule in rules[nextSym]:
                            ppos = self.skip(prule)
                            new = (prule, ppos)
                            NK.items.append(new)
            #

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

Open

def _namelist(instance):
    namelist, namedict, classlist = [], {}, [instance.__class__]
    for c in classlist:
        for b in c.__bases__:
            classlist.append(b)  # pylint: disable=W4701

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if nk is not None:
                            self.add(cur, (nk, i))

Avoid deeply nested control flow statements.

Open

                        if new not in cur:
                            self.links[key] = []
                            cur.append(new)
                        self.links[key].append((pptr, why))

Avoid deeply nested control flow statements.

Open

                        if nk is not None:
                            # self.add(cur, (nk, i))
                            # INLINED --v
                            new = (nk, i)
                            if new not in cur:

Avoid deeply nested control flow statements.

Open

                        if nk is not None:
                            self.add(next_item, (nk, i + 1))

Function add has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def add(self, input_set, item, i=None, predecessor=None, causal=None):

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

Open

    def preorder(self, node=None):
        if node is None:
            node = self.ast

        try:

• Read up
  Read up

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

Open

    def add(self, input_set, item, i=None, predecessor=None, causal=None):
        if predecessor is None:
            if item not in input_set:
                input_set.append(item)
        else:

• Read up
  Read up