def _generate_min_capability()

in lisa/schema.py [0:0]

• 75 lines of code
• 22 McCabe index (conditional complexity)

    def _generate_min_capability(self, capability: Any) -> Any:
        # copy to duplicate extended schema
        min_value: NodeSpace = copy.deepcopy(self)
        assert isinstance(capability, NodeSpace), f"actual: {type(capability)}"

        if self.node_count or capability.node_count:
            if isinstance(self.node_count, int) and isinstance(
                capability.node_count, int
            ):
                # capability can have more node
                min_value.node_count = capability.node_count
            else:
                min_value.node_count = search_space.generate_min_capability_countspace(
                    self.node_count, capability.node_count
                )
        else:
            raise LisaException("node_count cannot be zero")
        if self.core_count or capability.core_count:
            min_value.core_count = search_space.generate_min_capability_countspace(
                self.core_count, capability.core_count
            )
        else:
            raise LisaException("core_count cannot be zero")
        if self.memory_mb or capability.memory_mb:
            min_value.memory_mb = search_space.generate_min_capability_countspace(
                self.memory_mb, capability.memory_mb
            )
        else:
            raise LisaException("memory_mb cannot be zero")
        if self.disk or capability.disk:
            min_value.disk = search_space.generate_min_capability(
                self.disk, capability.disk
            )
        if self.network_interface or capability.network_interface:
            min_value.network_interface = search_space.generate_min_capability(
                self.network_interface, capability.network_interface
            )

        if self.gpu_count or capability.gpu_count:
            min_value.gpu_count = search_space.generate_min_capability_countspace(
                self.gpu_count, capability.gpu_count
            )
        else:
            min_value.gpu_count = 0

        if capability.features:
            min_value.features = search_space.SetSpace[FeatureSettings](
                is_allow_set=True
            )
            for original_cap_feature in capability.features:
                capability_feature = self._get_or_create_feature_settings(
                    original_cap_feature
                )
                requirement_feature = (
                    self._find_feature_by_type(capability_feature.type, self.features)
                    or capability_feature
                )
                min_feature = requirement_feature.generate_min_capability(
                    capability_feature
                )
                min_value.features.add(min_feature)
        if capability.excluded_features:
            # TODO: the min value for excluded feature is not clear. It may need
            # to be improved with real scenarios.
            min_value.excluded_features = search_space.SetSpace[FeatureSettings](
                is_allow_set=False
            )
            for original_cap_feature in capability.excluded_features:
                capability_feature = self._get_or_create_feature_settings(
                    original_cap_feature
                )
                requirement_feature = (
                    self._find_feature_by_type(
                        capability_feature.type, self.excluded_features
                    )
                    or capability_feature
                )
                min_feature = requirement_feature.generate_min_capability(
                    capability_feature
                )
                min_value.excluded_features.add(min_feature)
        return min_value