File asmap.py has 661 lines of code (exceeds 250 allowed). Consider refactoring.

Open

# Copyright (c) 2022 Pieter Wuille
# Distributed under the MIT software license, see the accompanying
# file LICENSE or http://www.opensource.org/licenses/mit-license.php.

"""

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

Open

def main():

    # Enable debug logging if running in CI
    if 'CI' in os.environ and os.environ['CI'].lower() == "true":
        logging.getLogger().setLevel(logging.DEBUG)

• Read up
  Read up

File verify.py has 541 lines of code (exceeds 250 allowed). Consider refactoring.

Open

#!/usr/bin/env python3
# Copyright (c) 2020-2021 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Script for verifying Bitcoin Core release binaries.

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

Open

def main():
    parser = argparse.ArgumentParser(
        description=__doc__.format(clang_format_diff="%(prog)s"),
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )

• Read up
  Read up

Function test_patching has a Cognitive Complexity of 43 (exceeds 5 allowed). Consider refactoring.

Open

    def test_patching(self) -> None:
        """Test behavior of update, lookup, extends, and diff."""
        #pylint: disable=too-many-locals,too-many-nested-blocks
        # Iterate over the number of leaves the random test ASMap objects have.
        for leaves in range(1, 20):

• Read up
  Read up

File copyright_header.py has 426 lines of code (exceeds 250 allowed). Consider refactoring.

Open

#!/usr/bin/env python3
# Copyright (c) 2016-2022 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.

Function _to_entries_minimal has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

    def _to_entries_minimal(self, fill: bool = False) -> list[ASNEntry]:
        """Convert a trie to a minimal list of ASNEntry objects, exploiting overlap."""
        prefix : list[bool] = []

        def recurse(node: list) -> (tuple[dict[Optional[int], list[ASNEntry]], bool]):

• Read up
  Read up

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

Open

    def _to_binnode(self, fill: bool = False) -> _BinNode:
        """Convert a trie to a _BinNode object."""
        def recurse(node: list) -> tuple[dict[Optional[int], _BinNode], bool]:
            if len(node) == 1 and node[0] == 0:
                return {(None if fill else 0): _BinNode.make_end()}, True

• Read up
  Read up

Function name_to_bip155 has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.

Open

def name_to_bip155(addr):
    '''Convert address string to BIP155 (networkID, addr) tuple.'''
    if addr.endswith('.onion'):
        vchAddr = b32decode(addr[0:-6], True)
        if len(vchAddr) == 35:

• Read up
  Read up

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

Open

def parseline(line: str) -> Union[dict, None]:
    """ Parses a line from `seeds_main.txt` into a dictionary of details for that line.
    or `None`, if the line could not be parsed.
    """
    if line.startswith('#'):

• Read up
  Read up

Function attack_rate has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.

Open

def attack_rate(period, bufsize, limit=None):
    """Compute maximal accepted headers per attack in (period, bufsize) configuration.

    If limit is provided, the computation is stopped early when the result is known to exceed the
    value in limit.

• Read up
  Read up

Function run has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.

Open

    def run(self):
        while self.blkCountOut < len(self.blkindex):
            if not self.inF:
                fname = self.inFileName(self.inFn)
                print("Input file " + fname)

• Read up
  Read up

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

Open

def loop(screen, bpf, peers):
    screen.nodelay(1)
    cur_list_pos = 0
    win = curses.newwin(30, 70, 2, 7)
    win.erase()

• Read up
  Read up

Function process_file has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.

Open

def process_file(path: str, messages: list[Any], recv: bool, progress_bar: Optional[ProgressBar]) -> None:
    with open(path, 'rb') as f_in:
        if progress_bar:
            bytes_read = 0

• Read up
  Read up

Function print_image has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

def print_image(img, threshold=128):
    '''Print black-and-white image to terminal in braille unicode characters.'''
    x_blocks = (img.size[0] + BW - 1) // BW
    y_blocks = (img.size[1] + BH - 1) // BH

• Read up
  Read up

File mempool_monitor.py has 287 lines of code (exceeds 250 allowed). Consider refactoring.

Open

#!/usr/bin/env python3
# Copyright (c) 2022 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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

Open

    def diff(self, other: "ASMap") -> list[ASNDiff]:
        """Compute the diff from self to other."""
        prefix: list[bool] = []
        ret: list[ASNDiff] = []

• Read up
  Read up

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

Open

    def from_binary(bindata: bytes) -> Optional["ASMap"]:
        """Decode an ASMap object from the provided binary encoding."""

        bits: list[int] = []
        for byte in bindata:

• Read up
  Read up

Function find_bufsize has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

def find_bufsize(period, attack_headers, when, max_mem=None, min_bufsize=1):
    """Determine how big bufsize needs to be given a specific period length.

    Given a period, find the smallest value of bufsize such that the attack rate against the
    (period, bufsize) configuration is below attack_headers. If max_mem is provided, and no

• Read up
  Read up

Function writeBlock has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def writeBlock(self, inhdr, blk_hdr, rawblock):
        blockSizeOnDisk = len(inhdr) + len(blk_hdr) + len(rawblock)
        if not self.fileOutput and ((self.outsz + blockSizeOnDisk) > self.maxOutSz):
            self.outF.close()
            if self.setFileTime:

• Read up
  Read up