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

Open

    def to_binary(self, fill: bool = False) -> bytes:
        """
        Convert this ASMap object to binary.

        Argument:

• 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 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

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 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

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 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

                        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 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):

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 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

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

                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 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 parse_spec has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

def parse_spec(s):
    '''Convert endpoint string to BIP155 (networkID, addr, port) tuple.'''
    match = re.match(r'\[([0-9a-fA-F:]+)\](?::([0-9]+))?$', s)
    if match: # ipv6
        host = match.group(1)

• Read up
  Read up

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

Open

    def from_random(num_leaves: int = 10, max_asn: int = 6,
                    unassigned_prob: float = 0.5) -> "ASMap":
        """
        Construct a random ASMap object, with specified:
         - Number of leaves in its trie (at least 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