Complexity calculation is unnecessarily high for chained method calls

[mwgamble]

Describe the bug

We have a builder class that we'll instantiate and get a result from all in a single statement. This works well because most of the time we only need to set a few things on the builder, and we don't want the builder to live on once the result has been obtained.

These expressions do not look complex. There is nothing nested. However, these statements fail on ECE001.

To Reproduce

Put this code in a file named test.py:

class MyClass:
    def __init__(self):
        self.prop1 = None
        self.prop2 = None
        self.prop3 = None

    def method1(self, prop1):
        self.prop1 = prop1
        return self

    def method2(self, prop2):
        self.prop2 = prop2
        return self

    def method3(self, prop3):
        self.prop3 = prop3
        return self

    def build(self):
        return {
            "prop1": self.prop1,
            "prop2": self.prop2,
            "prop3": self.prop3,
        }

x = MyClass().method1("a").method2("b").method3("c").build()
print(x)

Install flake8-expression-complexity.

Put this config in a file named setup.cfg:

[flake8]
select =
    # Regular flake8 rules
    C, E, F, W
    # flake8-expression-complexity
    ECE

Run flake8 test.py in the directory containing these files. Observe the following output:

test.py:27:1: ECE001 Expression is too complex (7.5 > 7)

Also observe that flake8 exits with a non-zero exit status code.

Expected behavior

Running flake8 test.py results in no errors and an exit status of 0.

Additional context

Basically it isn't clear why these chained method calls are considered "complex".