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

Open

    def _save_to_json(matrix, filename, verbose=False):
        result = []
        type_label_mapping = {}

        for line in matrix:

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                    if nsid == ns_id and paths["Name"] == controller_name:
                        stat.extend([paths["State"], paths["ANAState"]])
    return stat

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

Open

    def read_gdb_response(self, timeout=0.01, max_tries=100):
        """
        Read raw responses from GDB

        :param timeout: the amount of time to way between read attempts

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                    if result.exit_status != 0:
                        errs.append("remove loop device")
                        LOGGER.error(
                            "Unexpected failure when removing loop"
                            "device %s, check the log",

Avoid deeply nested control flow statements.

Open

                        if not isinstance(old, list):
                            node.value[n] = [node.value[n]]
                        node.value[n].append(v)

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

Open

def vg_ramdisk(

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

Open

def hash_file(filename, size=None, algorithm="md5"):
    """
    Calculate the hash value of filename.

    If size is not None, limit to first size bytes.

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                    with open(
                        os.path.join(root, metadata_file), "r", encoding="utf-8"
                    ) as data:
                        metadata = json.loads(data.read())
                    if isinstance(metadata, dict):

Avoid deeply nested control flow statements.

Open

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

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

Open

    def find_rpm_packages(self, rpm_dir):
        """
        Extract product dependencies from a defined RPM directory and all its subdirectories.

        :param str rpm_dir: directory to search in

• Read up
  Read up

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

Open

    def __init__(
        self,
        path=None,
        port=None,
        wait_until_running=True,

• Read up
  Read up

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:

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

Open

    def provides(self, name):
        """
        Searches for what provides a given file.

        :param name: File path.

• Read up
  Read up

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

Open

    def get_distro(self):
        """
        :param session: ssh connection between another machine

        Returns the :class:`LinuxDistro` this probe detected

• Read up
  Read up

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

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

                        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 param_type is not None:
                        param_dic["type"] = param_type.group(1)
                    param_list.append(param_dic)

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 next_item:
                            next_item.append(new)
                        # INLINED --^
            else: