Source code for dnachisel.builtin_specifications.EnforceRegionsCompatibility

from collections import Counter
import itertools

from ..Location import Location
from ..Specification import Specification, SpecEvaluation




class EnforceRegionsCompatibility(Specification):
    """Ensure that different subregions satisfy compatibility constraints."""

    max_possible_score = 0

    def __init__(
        self, locations, compatibility_condition, condition_label="", boost=1.0
    ):
        self.locations = [Location.from_tuple(location) for location in locations]
        self.compatibility_condition = compatibility_condition
        self.condition_label = condition_label
        self.boost = boost

    def evaluate(self, problem):
        incompatible_locations_pairs = []
        for r1, r2 in itertools.combinations(self.locations, 2):
            if not self.compatibility_condition(r1, r2, problem):
                incompatible_locations_pairs.append((r1, r2))

        all_locations_with_incompatibility = [
            region
            for incompatibles_pair in incompatible_locations_pairs
            for region in incompatibles_pair
        ]
        counter = Counter(all_locations_with_incompatibility)
        all_locations_with_incompatibility = sorted(
            list(set(all_locations_with_incompatibility)), key=counter.get
        )

        score = -len(incompatible_locations_pairs)
        if score == 0:
            message = "All compatible !"
        else:
            message = "Found the following incompatibilities: %s" % (
                incompatible_locations_pairs
            )
        return SpecEvaluation(
            self,
            problem,
            score=score,
            locations=all_locations_with_incompatibility,
            message=message,
        )

    def localized(self, location, problem=None):
        if any(location.overlap_region(rl) for rl in self.locations):
            return self
        else:
            return None  # (parent=self)

    def __repr__(self):
        return "CompatRegions(%s%s...)" % (self.condition_label, self.locations[0])

    def __str__(self):
        return "CompatRegions(%s%s...)" % (self.condition_label, self.locations[0])

    def label_parameters(self):
        params = [("locations", ", ".join([str(l) for l in self.locations]))]
        if self.condition_label not in [None, ""]:
            params.append(("condition", self.condition_label))
        return params