def check()

in lisa/schema.py [0:0]

• 67 lines of code
• 18 McCabe index (conditional complexity)

    def check(self, capability: Any) -> search_space.ResultReason:
        result = search_space.ResultReason()
        if capability is None:
            result.add_reason("capability shouldn't be None")

        if self.features:
            assert self.features.is_allow_set, "features should be allow set"
        if self.excluded_features:
            assert (
                not self.excluded_features.is_allow_set
            ), "excluded_features shouldn't be allow set"

        assert isinstance(capability, NodeSpace), f"actual: {type(capability)}"

        if (
            not capability.node_count
            or not capability.core_count
            or not capability.memory_mb
        ):
            result.add_reason(
                "node_count, core_count, memory_mb " "shouldn't be None or zero."
            )

        if isinstance(self.node_count, int) and isinstance(capability.node_count, int):
            if self.node_count > capability.node_count:
                result.add_reason(
                    f"capability node count {capability.node_count} "
                    f"must be more than requirement {self.node_count}"
                )
        else:
            result.merge(
                search_space.check_countspace(self.node_count, capability.node_count),
                "node_count",
            )

        result.merge(
            search_space.check_countspace(self.core_count, capability.core_count),
            "core_count",
        )
        result.merge(
            search_space.check_countspace(self.memory_mb, capability.memory_mb),
            "memory_mb",
        )
        if self.disk:
            result.merge(self.disk.check(capability.disk))
        if self.network_interface:
            result.merge(self.network_interface.check(capability.network_interface))
        result.merge(
            search_space.check_countspace(self.gpu_count, capability.gpu_count),
            "gpu_count",
        )
        if self.features:
            for feature in self.features:
                cap_feature = self._find_feature_by_type(
                    feature.type, capability.features
                )
                if cap_feature:
                    result.merge(feature.check(cap_feature))
                else:
                    result.add_reason(
                        f"no feature '{feature.type}' found in capability"
                    )
        if self.excluded_features:
            for feature in self.excluded_features:
                cap_feature = self._find_feature_by_type(
                    feature.type, capability.excluded_features
                )
                if cap_feature:
                    result.add_reason(
                        f"excluded feature '{feature.type}' found in capability"
                    )

        return result