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

Open

    def _set_trie(self, trie) -> None:
        """Set trie directly. Internal use only."""
        def recurse(node: list) -> None:
            if len(node) < 2:
                return

• Read up
  Read up

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

Open

def tree_sha512sum(commit='HEAD'):
    """Calculate the Tree-sha512 for the commit.

    This is copied from github-merge.py. See https://github.com/bitcoin-core/bitcoin-maintainer-tools."""

• Read up
  Read up

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

Open

    def test_asmap_roundtrips(self) -> None:
        """Test case that verifies random ASMap objects roundtrip to/from entries/binary."""
        # Iterate over the number of leaves the random test ASMap objects have.
        for leaves in range(1, 20):
            # Iterate over the number of bits in the AS numbers used.

• Read up
  Read up

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

Open

def parse_config_into_btc_config():
    def find_between( s, first, last ):
        try:
            start = s.index( first ) + len( first )
            end = s.index( last, start )

• Read up
  Read up

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

Open

def is_valid(v):
    '''Check vector v for validity'''
    if len(set(v) - set(b58chars)) > 0:
        return is_valid_bech32(v)
    try:

• Read up
  Read up

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

Open

def print_report(file_infos, verbose):
    print(SEPARATOR)
    examined = [i['filename'] for i in file_infos]
    print("%d files examined according to INCLUDE and EXCLUDE fnmatch rules" %
          len(examined))

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                    if limit is not None and rate >= limit:
                        return rate, None
                    # If the maximal term being added is negligible compared to rate, stop
                    # iterating.
                    if HEADER_BATCH_COUNT * prob < 1.0e-16 * rate * len(align_choices):

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

Open

    def make_branch(node0: "_BinNode", node1: "_BinNode") -> "_BinNode":
        """
        Construct a _BinNode corresponding to running either the node0 or node1 subprogram,
        based on the next input bit. It exploits shortcuts that are possible in the encoding,
        and uses either a JUMP, MATCH, or END instruction.

• Read up
  Read up

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

Open

def main():
    parser = argparse.ArgumentParser(
        description=__doc__,
        epilog="EXAMPLE \n\t{0} -o out.json <data-dir>/message_capture/**/*.dat".format(sys.argv[0]),
        formatter_class=argparse.RawTextHelpFormatter)

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                if line.startswith("SF:") and p in line:
                    in_remove = True
            if not in_remove:

Avoid deeply nested control flow statements.

Open

                        if val[0] < threshold:
                            ch |= BIT_PER_PIXEL[y][x]
            line.append(chr(ch))

Avoid deeply nested control flow statements.

Open

                for dep in deps[src]:
                    if dep not in closure:
                        closure[dep] = closure[src] + [src]
            if len(closure) == old_size:

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

Open

    def update(self, prefix: list[bool], asn: int) -> None:
        """Update this ASMap object to map prefix to the specified asn."""
        assert asn == 0 or _CODER_ASN.can_encode(asn)

        def recurse(node: list, offset: int) -> None:

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        for path, old_asn, new_asn in diff:
                            # Verify asmap and patched actually differ there.
                            self.assertTrue(old_asn != new_asn)
                            self.assertEqual(asmap.lookup(path), old_asn)
                            self.assertEqual(patched.lookup(path), new_asn)

Avoid deeply nested control flow statements.

Open

                    if HEADER_BATCH_COUNT * prob < 1.0e-16 * rate * len(align_choices):
                        break
                # Update state from a new incoming batch (which is all forged)
                after_good_commit += HEADER_BATCH_COUNT

Avoid deeply nested control flow statements.

Open

                if included_module is not None and included_module in deps and included_module != module:
                    deps[module].add(included_module)

# Loop to find the shortest (remaining) circular dependency
have_cycle: bool = False

Function render has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

def render(screen, peers, cur_list_pos, scroll, ROWS_AVALIABLE_FOR_LIST, info_panel):

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

Open

def find_bufsize(period, attack_headers, when, max_mem=None, min_bufsize=1):

Function process_nodes has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

def process_nodes(g, f, structname):
    g.write('static const uint8_t %s[] = {\n' % structname)
    for line in f:
        comment = line.find('#')
        if comment != -1:

• Read up
  Read up

Function encode has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def encode(self, val: int, ret: list[int]) -> None:
        """Append encoding of val onto integer list ret."""

        assert self._minval <= val <= self._maxval
        val -= self._minval

• Read up
  Read up