def satisfied_by_node()

in src/hpc/autoscale/node/constraints.py [0:0]

• 50 lines of code
• 10 McCabe index (conditional complexity)

    def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
        if self.attr not in node.available:
            return SatisfiedResult(
                "UndefinedResource",
                self,
                node,
                [
                    "Resource[name={}] not defined for Node[name={} hostname={}]".format(
                        self.attr, node.name, node.hostname
                    )
                ],
            )
        target = node.available[self.attr]

        if self.case_insensitive and isinstance(target, str):
            target = target.lower()

        for n, value in enumerate(self.values):
            if isinstance(value, str) and isinstance(target, str):
                matches = fnmatch(target, value)
            else:
                matches = target == value
            if matches:
                score = len(self.values) - n
                return SatisfiedResult(
                    "success",
                    self,
                    node,
                    score=score,
                )

        if node._is_example_node():
            node_str = "Bucket[array={} vm_size={} attr={}]".format(
                node.nodearray, node.vm_size, self.attr
            )
        else:
            node_str = "Node[name={} attr={}]".format(node.name, self.attr)

        if len(self.values) > 1:
            msg = (
                "Resource[name={} value={}] is not one of the options {} for {}".format(
                    self.attr, repr(target), self.values, node_str
                )
            )
        else:
            msg = "Resource[name={} value={}] != {} for {}".format(
                self.attr, repr(target), repr(self.values[0]), node_str
            )

        return SatisfiedResult(
            "InvalidOption",
            self,
            node,
            [msg],
        )