flamapy-sat 2.6.0.dev4__tar.gz → 2.6.0.dev5__tar.gz

{flamapy_sat-2.6.0.dev4/flamapy_sat.egg-info → flamapy_sat-2.6.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-sat
-Version: 2.6.0.dev4
+Version: 2.6.0.dev5
 Summary: flamapy-sat is a plugin to flamapy module
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,8 +8,8 @@ Project-URL: Homepage, https://github.com/flamapy/pysat_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.6.0.dev4
-Requires-Dist: flamapy-fm~=2.6.0.dev4
+Requires-Dist: flamapy-fw~=2.6.0.dev5
+Requires-Dist: flamapy-fm~=2.6.0.dev5
 Requires-Dist: python-sat~=0.1.7.dev1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"

flamapy_sat-2.6.0.dev5/flamapy/metamodels/pysat_diagnosis_metamodel/operations/__init__.py

@@ -0,0 +1,20 @@
+# pylint: disable=cyclic-import
+
+from .pysat_abstract_identifier import PySATAbstractIdentifier
+from .pysat_conflict import PySATConflict
+from .pysat_diagnosis import PySATDiagnosis
+from .pysat_configuration_diagnosis import (
+    PySATConfigurationConflict,
+    PySATConfigurationRepair,
+    PySATFeatureExplanation,
+)
+
+
+__all__ = [
+    'PySATAbstractIdentifier',
+    'PySATConfigurationConflict',
+    'PySATConfigurationRepair',
+    'PySATConflict',
+    'PySATDiagnosis',
+    'PySATFeatureExplanation',
+]

flamapy_sat-2.6.0.dev5/flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_configuration_diagnosis.py

@@ -0,0 +1,162 @@
+"""Diagnosis-powered operations for interactive configuration.
+
+These turn the low-level QuickXPlain/FastDiag machinery into configuration-level answers
+that a configurator can surface directly:
+
+- ``PySATConfigurationConflict``: a minimal set of user decisions that together with the
+  model are inconsistent ("these choices clash").
+- ``PySATConfigurationRepair``: a minimal set of decisions to retract to restore
+  consistency ("undo one of these to continue").
+- ``PySATFeatureExplanation``: for a feature that is forced by the current decisions, the
+  minimal set of decisions responsible ("this feature is on because of these choices").
+
+Each consumes a ``PySATModel`` (the feature-model CNF) and a partial ``Configuration``.
+Decisions are returned as ``(feature_name, selected)`` pairs.
+"""
+from typing import Optional, cast
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+from flamapy.metamodels.pysat_metamodel.models.pysat_model import PySATModel
+
+from .diagnosis.checker import ConsistencyChecker
+from .diagnosis.quickxplain import QuickXPlain
+from .diagnosis.fastdiag import FastDiag
+
+
+Decision = tuple[str, bool]
+
+
+def _clauses_and_decisions(
+    model: PySATModel, configuration: Configuration
+) -> tuple[list[list[int]], list[tuple[int, str, bool]]]:
+    clauses = [list(clause) for clause in model.get_all_clauses().clauses]
+    decisions: list[tuple[int, str, bool]] = []
+    for name, value in configuration.elements.items():
+        variable = model.variables.get(name)
+        if variable is None:
+            continue
+        selected = bool(value)
+        decisions.append((variable if selected else -variable, name, selected))
+    return clauses, decisions
+
+
+def _decisions_from_literals(
+    literals: list[int], decisions: list[tuple[int, str, bool]]
+) -> list[Decision]:
+    by_literal = {literal: (name, value) for literal, name, value in decisions}
+    return [by_literal[literal] for literal in literals if literal in by_literal]
+
+
+class PySATConfigurationConflict(Operation):
+    """Minimal subset of the user's decisions that is inconsistent with the model."""
+
+    def __init__(self) -> None:
+        self._configuration: Optional[Configuration] = None
+        self._result: list[Decision] = []
+
+    def set_configuration(self, configuration: Configuration) -> None:
+        self._configuration = configuration
+
+    def get_conflict(self) -> list[Decision]:
+        return self._result
+
+    def get_result(self) -> list[Decision]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATConfigurationConflict':
+        sat_model = cast(PySATModel, model)
+        clauses, decisions = _clauses_and_decisions(sat_model, self._configuration)
+        checker = ConsistencyChecker('glucose3', clauses)
+        conflict = QuickXPlain(checker).find_conflict([lit for lit, _, _ in decisions], [])
+        checker.delete()
+        self._result = _decisions_from_literals(conflict, decisions)
+        return self
+
+
+class PySATConfigurationRepair(Operation):
+    """Minimal subset of the user's decisions to retract to restore consistency."""
+
+    def __init__(self) -> None:
+        self._configuration: Optional[Configuration] = None
+        self._result: list[Decision] = []
+
+    def set_configuration(self, configuration: Configuration) -> None:
+        self._configuration = configuration
+
+    def get_repair(self) -> list[Decision]:
+        return self._result
+
+    def get_result(self) -> list[Decision]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATConfigurationRepair':
+        sat_model = cast(PySATModel, model)
+        clauses, decisions = _clauses_and_decisions(sat_model, self._configuration)
+        checker = ConsistencyChecker('glucose3', clauses)
+        diagnosis = FastDiag(checker).find_diagnosis([lit for lit, _, _ in decisions], [])
+        checker.delete()
+        self._result = _decisions_from_literals(diagnosis, decisions)
+        return self
+
+
+class PySATFeatureExplanation(Operation):
+    """Explain why a feature is forced by the current decisions.
+
+    ``get_forced_value()`` is the value the feature is forced to (or ``None`` if it is not
+    forced), and ``get_result()`` is the minimal set of decisions responsible.
+    """
+
+    def __init__(self) -> None:
+        self._configuration: Optional[Configuration] = None
+        self._feature: Optional[str] = None
+        self._forced_value: Optional[bool] = None
+        self._result: list[Decision] = []
+
+    def set_configuration(self, configuration: Configuration) -> None:
+        self._configuration = configuration
+
+    def set_feature(self, feature_name: str) -> None:
+        self._feature = feature_name
+
+    def get_forced_value(self) -> Optional[bool]:
+        return self._forced_value
+
+    def get_explanation(self) -> list[Decision]:
+        return self._result
+
+    def get_result(self) -> list[Decision]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATFeatureExplanation':
+        sat_model = cast(PySATModel, model)
+        self._forced_value = None
+        self._result = []
+        if self._feature is None:
+            return self
+        clauses, decisions = _clauses_and_decisions(sat_model, self._configuration)
+        variable = sat_model.variables.get(self._feature)
+        if variable is None:
+            return self
+
+        literals = [lit for lit, _, _ in decisions]
+        checker = ConsistencyChecker('glucose3', clauses)
+        can_be_true = checker.is_consistent([*literals, variable], [])
+        can_be_false = checker.is_consistent([*literals, -variable], [])
+        if can_be_true and not can_be_false:
+            self._forced_value = True
+            forbidden = -variable
+        elif can_be_false and not can_be_true:
+            self._forced_value = False
+            forbidden = variable
+        else:
+            checker.delete()  # not forced (or already contradictory) -> no explanation
+            return self
+
+        # The minimal decisions that, with the model, entail the forced value are those
+        # inconsistent with the model plus the opposite assignment.
+        explanation = QuickXPlain(checker).find_conflict(literals, [forbidden])
+        checker.delete()
+        self._result = _decisions_from_literals(explanation, decisions)
+        return self

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_diagnosis_metamodel/transformations/fm_to_diag_pysat.py

@@ -20,8 +20,8 @@ class FmToDiagPysat(FmToPysat):
     def get_destination_extension() -> str:
         return 'pysat_diagnosis'
 
-    def __init__(self, source_model: FeatureModel) -> None:
-        super().__init__(source_model)
+    def __init__(self, source_model: FeatureModel, cnf_method: str = 'distributive') -> None:
+        super().__init__(source_model, cnf_method)
         self.destination_model = DiagnosisModel()
 
     def add_root(self, feature: Feature) -> None:
@@ -51,20 +51,20 @@ class FmToDiagPysat(FmToPysat):
         self.destination_model.add_clause_to_map(str(relation), clauses)
 
     def add_constraint(self, ctc: Constraint) -> None:
-        def get_term_variable(term: Any) -> int:
-            negated = False
-            if term.startswith('-'):
-                term = term[1:]
-                negated = True
-
-            var = self.destination_model.get_variable(term)
+        if self.cnf_method == 'tseytin':
+            clauses, aux_names = ctc.ast.get_clauses_with_aux(method='tseytin')
+            aux_map = self._allocate_auxiliary(aux_names)
+        else:
+            clauses = ctc.ast.get_clauses()
+            aux_map = {}
 
-            if negated:
-                return -var
-            return var
+        def get_term_variable(term: Any) -> int:
+            negated = term.startswith('-')
+            name = term[1:] if negated else term
+            var = aux_map[name] if name in aux_map else self.destination_model.get_variable(name)
+            return -var if negated else var
 
         ctc_clauses = []
-        clauses = ctc.ast.get_clauses()
         for clause in clauses:
             clause_variables = list(map(get_term_variable, clause))
             ctc_clauses.append(clause_variables)

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/models/pysat_model.py

@@ -13,6 +13,9 @@ class PySATModel(VariabilityModel):
         self._cnf = CNF()
         self.variables: dict[str, int] = {}  # feature's name -> id
         self.features: dict[int, str] = {}  # id -> feature's name
+        # Auxiliary (Tseytin) variable ids that are not features. They must be excluded
+        # from feature enumeration/counting; models over the features are unaffected.
+        self.auxiliary_variables: set[int] = set()
         self.original_model: VariabilityModel
 
     def add_clause(self, clause: list[int]) -> None:

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/operations/__init__.py

@@ -9,9 +9,13 @@ from .pysat_core_features import PySATCoreFeatures
 from .pysat_dead_features import PySATDeadFeatures
 from .pysat_false_optional_features import PySATFalseOptionalFeatures
 from .pysat_metrics import PySATMetrics
+from .pysat_attribute_optimization import PySATAttributeOptimization
+from .pysat_minimum_configuration import PySATMinimumConfiguration
+from .pysat_twise_sampling import PySATTWiseSampling
 
 
 __all__ = [
+    'PySATAttributeOptimization',
     'PySATBackbone',
     'PySATCommonality',
     'PySATConfigurations',
@@ -21,6 +25,8 @@ __all__ = [
     'PySATFalseOptionalFeatures',
     'PySATFilter',
     'PySATMetrics',
+    'PySATMinimumConfiguration',
     'PySATSatisfiable',
     'PySATSatisfiableConfiguration',
+    'PySATTWiseSampling',
 ]

flamapy_sat-2.6.0.dev5/flamapy/metamodels/pysat_metamodel/operations/pysat_attribute_optimization.py

@@ -0,0 +1,127 @@
+from typing import Any, Optional, cast
+
+from pysat.formula import WCNF
+from pysat.examples.rc2 import RC2
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import AttributeOptimization, OptimizationGoal
+from flamapy.core.exceptions import FlamaException
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+from flamapy.metamodels.fm_metamodel.models.feature_model import FeatureModel
+from flamapy.metamodels.pysat_metamodel.models.pysat_model import PySATModel
+
+
+class PySATAttributeOptimization(AttributeOptimization):
+    """Optimal configuration for a single numeric feature attribute, via MaxSAT (RC2).
+
+    The objective is the sum of the attribute value over the selected features. The SAT
+    clauses are the hard constraints; per-feature attribute values become weighted soft
+    clauses so RC2 returns a valid configuration with the optimal objective.
+
+    Multi-objective/Pareto optimization is not supported here — use the z3 backend for that.
+    """
+
+    def __init__(self) -> None:
+        self._attributes: dict[str, OptimizationGoal] = {}
+        self._result: list[Configuration] = []
+        self._optimum: dict[str, float] = {}
+
+    def set_attributes(self, attributes: dict[str, OptimizationGoal]) -> None:
+        self._attributes = attributes
+
+    def optimize(self) -> list[Configuration]:
+        return self.get_result()
+
+    def get_result(self) -> list[Configuration]:
+        return self._result
+
+    def get_optimum(self) -> dict[str, float]:
+        """The optimal objective value per attribute, e.g. ``{'Cost': 12.0}``."""
+        return self._optimum
+
+    def execute(self, model: VariabilityModel) -> 'PySATAttributeOptimization':
+        sat_model = cast(PySATModel, model)
+        if len(self._attributes) != 1:
+            raise FlamaException(
+                'PySATAttributeOptimization optimizes a single attribute; use the z3 '
+                'backend for multi-objective/Pareto optimization.'
+            )
+        (attr_name, goal), = self._attributes.items()
+        feature_model = getattr(sat_model, 'original_model', None)
+        if feature_model is None:
+            raise FlamaException(
+                'The SAT model has no attached feature model to read attributes from.'
+            )
+        weights = _feature_weights(cast(FeatureModel, feature_model), attr_name)
+        config, optimum = _optimize(sat_model, weights, goal)
+        if config is None or optimum is None:
+            self._result = []
+            self._optimum = {}
+        else:
+            self._result = [config]
+            self._optimum = {attr_name: optimum}
+        return self
+
+
+def _feature_weights(feature_model: FeatureModel, attribute_name: str) -> dict[str, float]:
+    """Map each feature carrying the given numeric attribute to its value."""
+    weights: dict[str, float] = {}
+    for feature in feature_model.get_features():
+        for attribute in feature.get_attributes():
+            value = attribute.default_value
+            if attribute.name == attribute_name and isinstance(value, (int, float)) \
+                    and not isinstance(value, bool):
+                weights[feature.name] = float(value)
+    return weights
+
+
+def _integer_scale(values: list[float]) -> int:
+    """Smallest power of ten that turns all values into integers (capped at 1e6)."""
+    max_decimals = 0
+    for value in values:
+        text = f"{value:.6f}".rstrip('0')
+        if '.' in text:
+            max_decimals = max(max_decimals, len(text.split('.')[1]))
+    return 10 ** max_decimals
+
+
+def _optimize(sat_model: PySATModel,
+              weights: dict[str, float],
+              goal: OptimizationGoal) -> tuple[Optional[Configuration], Optional[float]]:
+    # Maximizing an objective is minimizing its negation.
+    sign = 1.0 if goal == OptimizationGoal.MINIMIZE else -1.0
+    effective = {name: sign * weight for name, weight in weights.items()}
+    scale = _integer_scale(list(effective.values()))
+
+    wcnf = WCNF()
+    for clause in sat_model.get_all_clauses():
+        wcnf.append(list(clause))  # hard clauses
+
+    for name, weight in effective.items():
+        variable = sat_model.variables.get(name)
+        if variable is None:
+            continue
+        int_weight = round(weight * scale)
+        if int_weight > 0:
+            # Cost paid when the feature is selected -> pushes it out to reduce the objective.
+            wcnf.append([-variable], weight=int_weight)
+        elif int_weight < 0:
+            # Cost paid when the feature is deselected -> pulls it in.
+            wcnf.append([variable], weight=-int_weight)
+
+    with RC2(wcnf) as rc2:
+        assignment = rc2.compute()
+        if assignment is None:
+            return None, None
+        selected_vars = {literal for literal in assignment if literal > 0}
+        elements: dict[Any, Any] = {}
+        for literal in assignment:
+            if literal > 0:
+                feature_name = sat_model.features.get(literal)
+                if feature_name is not None:  # skip auxiliary variables
+                    elements[feature_name] = True
+        configuration = Configuration(elements)
+
+    optimum = sum(weight for name, weight in weights.items()
+                  if sat_model.variables.get(name) in selected_vars)
+    return configuration, optimum

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/operations/pysat_configurations.py

@@ -35,7 +35,9 @@ def configurations(solver: Solver, model: PySATModel) -> list[Configuration]:
         product: dict[Any, bool] = {}
         for variable in solutions:
             if variable > 0:
-                product[model.features.get(variable)] = True
+                name = model.features.get(variable)
+                if name is not None:  # skip auxiliary (Tseytin) variables
+                    product[name] = True
         result.append(Configuration(product))
     solver.delete()
     return result

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/operations/pysat_configurations_number.py

@@ -25,6 +25,9 @@ class PySATConfigurationsNumber(ConfigurationsNumber):
         for clause in model.get_all_clauses():  # AC es conjunto de conjuntos
             self.solver.add_clause(clause)  # añadimos la constraint
 
+        # Auxiliary (Tseytin) variables are functionally determined by their biconditional
+        # gate definitions, so each feature-level model has exactly one full model here;
+        # the count is unaffected by their presence.
         for _ in self.solver.enum_models():
             self.products_number += 1
         self.solver.delete()

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/operations/pysat_false_optional_features.py

@@ -31,11 +31,11 @@ class PySATFalseOptionalFeatures(FalseOptionalFeatures):
         return self.result
 
     def _get_false_optional_features(self, sat_model: PySATModel) -> list[Any]:
-        try:
-            feature_model = cast(FeatureModel, sat_model.original_model)
-        except FlamaException:
-            LOGGER.exception("The transformation didn't attach the source model, "
-                             "which is required for this operation.")
+        original_model = getattr(sat_model, 'original_model', None)
+        if original_model is None:
+            raise FlamaException("The transformation didn't attach the source model, "
+                                 "which is required for this operation.")
+        feature_model = cast(FeatureModel, original_model)
 
         real_optional_features = [f for f in feature_model.get_features()
                                   if not f.is_root() and not f.is_mandatory()]

flamapy_sat-2.6.0.dev5/flamapy/metamodels/pysat_metamodel/operations/pysat_minimum_configuration.py

@@ -0,0 +1,49 @@
+from typing import Any, Optional, cast
+
+from pysat.formula import WCNF
+from pysat.examples.rc2 import RC2
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+from flamapy.metamodels.pysat_metamodel.models.pysat_model import PySATModel
+
+
+class PySATMinimumConfiguration(Operation):
+    """Return a valid configuration with the fewest selected features, via MaxSAT (RC2).
+
+    Every feature contributes a unit soft clause preferring it to be deselected, so the
+    optimum is a valid configuration minimizing the number of selected features (the
+    minimum working configuration).
+    """
+
+    def __init__(self) -> None:
+        self._result: Optional[Configuration] = None
+
+    def get_result(self) -> Optional[Configuration]:
+        return self._result
+
+    def get_minimum_configuration(self) -> Optional[Configuration]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATMinimumConfiguration':
+        sat_model = cast(PySATModel, model)
+        wcnf = WCNF()
+        for clause in sat_model.get_all_clauses():
+            wcnf.append(list(clause))  # hard clauses
+        for variable in sat_model.features:  # one unit soft clause per feature variable
+            wcnf.append([-variable], weight=1)
+
+        with RC2(wcnf) as rc2:
+            assignment = rc2.compute()
+            if assignment is None:
+                self._result = None
+                return self
+            elements: dict[Any, Any] = {}
+            for literal in assignment:
+                if literal > 0:
+                    feature_name = sat_model.features.get(literal)
+                    if feature_name is not None:  # skip auxiliary variables
+                        elements[feature_name] = True
+            self._result = Configuration(elements)
+        return self

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/operations/pysat_sampling.py

@@ -49,23 +49,48 @@ def sample(solver: Solver,
            model: PySATModel,
            sample_size: int,
            with_replacement: bool,  # pylint: disable=unused-argument
-           partial_configuration: Optional[Configuration]  # pylint: disable=unused-argument
+           partial_configuration: Optional[Configuration]
            ) -> list[Configuration]:
+    """Return up to ``sample_size`` valid configurations by enumeration.
+
+    ``partial_configuration`` restricts the sample to configurations that fix the given
+    feature selections (applied as SAT assumptions). Note this is a deterministic
+    enumerator, not a uniform random sampler: it returns distinct configurations, so
+    ``with_replacement`` has no effect here — for almost-uniform random sampling use the
+    ``flamapy-sharpsat`` (UniGen) backend instead.
+    """
     if sample_size == 0:
         return []
 
     for clause in model.get_all_clauses():
         solver.add_clause(clause)
 
+    assumptions = _partial_configuration_assumptions(model, partial_configuration)
+
     products = []
-    for solutions in solver.enum_models():
+    for solutions in solver.enum_models(assumptions=assumptions):
         product: dict[Any, bool] = {}
         for variable in solutions:
             if variable > 0:
-                product[model.features.get(variable)] = True
+                name = model.features.get(variable)
+                if name is not None:  # skip auxiliary (Tseytin) variables
+                    product[name] = True
         products.append(Configuration(product))
         if len(products) == sample_size:
             solver.delete()
             return products
     solver.delete()
     return products
+
+
+def _partial_configuration_assumptions(
+    model: PySATModel, partial_configuration: Optional[Configuration]
+) -> list[int]:
+    """SAT assumptions fixing the features decided in a partial configuration."""
+    assumptions: list[int] = []
+    if partial_configuration is not None:
+        for name, value in partial_configuration.elements.items():
+            variable = model.variables.get(name)
+            if variable is not None:
+                assumptions.append(variable if value else -variable)
+    return assumptions

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/operations/pysat_satisfiable_configuration.py

@@ -33,6 +33,15 @@ class PySATSatisfiableConfiguration(SatisfiableConfiguration):
         for clause in sat_model.get_all_clauses():  # AC es conjunto de conjuntos
             self.solver.add_clause(clause)  # añadimos la constraint
 
+        missing_features = [feature for feature in self.configuration.elements.keys()
+                            if feature not in sat_model.variables.keys()]
+        if missing_features:
+            logger.warning("The features that are missing are: %s", list(missing_features))
+            logger.warning("The feature model contains the following features: %s",
+                           list(sat_model.variables.keys()))
+            self.result = False
+            return self
+
         if not self.configuration.is_full:
             assumptions = []
             for feature, selected in self.configuration.elements.items():
@@ -41,16 +50,6 @@ class PySATSatisfiableConfiguration(SatisfiableConfiguration):
                 else:
                     assumptions.append(-sat_model.variables[feature])
         else:
-            missing_features = [feature for feature in self.configuration.elements.keys()
-                                if feature not in sat_model.variables.keys()]
-
-            if missing_features:
-                logger.warning("The features that are missing are: %s", list(missing_features))
-                logger.warning("The feature model contains the following features: %s",
-                               list(sat_model.variables.keys()))
-                self.result = False
-                return self
-
             assumptions = []
             for feature in sat_model.features.values():
 

flamapy_sat-2.6.0.dev5/flamapy/metamodels/pysat_metamodel/operations/pysat_twise_sampling.py

@@ -0,0 +1,86 @@
+import itertools
+from typing import Any, cast
+
+from pysat.solvers import Solver
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+from flamapy.metamodels.pysat_metamodel.models.pysat_model import PySATModel
+
+
+class PySATTWiseSampling(Operation):
+    """t-wise (combinatorial) sampling: a set of valid configurations that covers every
+    satisfiable combination of ``t`` feature selections.
+
+    For ``t = 2`` this yields a pairwise covering sample. The sample is built greedily:
+    each configuration is grown to cover as many still-uncovered feature combinations as
+    the constraints allow.
+    """
+
+    def __init__(self, t: int = 2) -> None:
+        self.t = t
+        self.result: list[Configuration] = []
+
+    def set_t(self, t: int) -> None:
+        self.t = t
+
+    def get_sample(self) -> list[Configuration]:
+        return self.result
+
+    def get_result(self) -> list[Configuration]:
+        return self.result
+
+    def execute(self, model: VariabilityModel) -> 'PySATTWiseSampling':
+        sat_model = cast(PySATModel, model)
+        self.result = _twise_sample(sat_model, self.t)
+        return self
+
+
+def _satisfiable_targets(solver: Solver, feature_vars: list[int], t: int) -> list[tuple[int, ...]]:
+    """Every satisfiable combination of ``t`` feature variables with each sign pattern."""
+    targets: list[tuple[int, ...]] = []
+    for combination in itertools.combinations(feature_vars, t):
+        for signs in itertools.product((1, -1), repeat=t):
+            literals = tuple(sign * var for sign, var in zip(signs, combination))
+            if solver.solve(assumptions=list(literals)):
+                targets.append(literals)
+    return targets
+
+
+def _twise_sample(model: PySATModel, t: int) -> list[Configuration]:
+    clauses = list(model.get_all_clauses().clauses)
+    solver = Solver(name='glucose3', bootstrap_with=clauses)
+    feature_vars = model.feature_variables() if hasattr(model, 'feature_variables') \
+        else list(model.features.keys())
+
+    uncovered = _satisfiable_targets(solver, feature_vars, t)
+    configurations: list[Configuration] = []
+
+    while uncovered:
+        current: set[int] = set(uncovered[0])
+        # Greedily merge other uncovered targets that stay jointly satisfiable.
+        for target in uncovered[1:]:
+            if any(-literal in current for literal in target):
+                continue
+            tentative = current | set(target)
+            if solver.solve(assumptions=list(tentative)):
+                current = tentative
+        solver.solve(assumptions=list(current))
+        assignment = solver.get_model() or []
+        configurations.append(_to_configuration(model, assignment))
+        satisfied = set(assignment)
+        uncovered = [tg for tg in uncovered if not set(tg).issubset(satisfied)]
+
+    solver.delete()
+    return configurations
+
+
+def _to_configuration(model: PySATModel, assignment: list[int]) -> Configuration:
+    elements: dict[Any, Any] = {}
+    for literal in assignment:
+        if literal > 0:
+            name = model.features.get(literal)
+            if name is not None:  # skip auxiliary variables
+                elements[name] = True
+    return Configuration(elements)

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy/metamodels/pysat_metamodel/transformations/fm_to_pysat.py

@@ -20,9 +20,13 @@ class FmToPysat(ModelToModel):
     def get_destination_extension() -> str:
         return 'pysat'
 
-    def __init__(self, source_model: FeatureModel) -> None:
+    def __init__(self, source_model: FeatureModel, cnf_method: str = 'distributive') -> None:
         self.source_model = source_model
         self.counter = 1
+        # 'distributive' (default) or 'tseytin'. Tseytin keeps complex cross-tree
+        # constraints compact at the cost of auxiliary variables; it is a framework-only
+        # opt-in and is not exposed through the facade/CLI.
+        self.cnf_method = cnf_method
         self.destination_model = PySATModel()
         self.destination_model.original_model = source_model
 
@@ -144,14 +148,31 @@ class FmToPysat(ModelToModel):
             clauses = self._add_constraint_relation(relation)
         self._store_constraint_clauses(clauses)
 
+    def _allocate_auxiliary(self, aux_names: list[str]) -> dict[str, int]:
+        """Assign a fresh SAT variable id to each Tseytin auxiliary name, recording it as
+        a non-feature auxiliary variable so it is excluded from feature enumeration."""
+        aux_map: dict[str, int] = {}
+        for name in aux_names:
+            var = self.counter
+            self.counter += 1
+            aux_map[name] = var
+            self.destination_model.auxiliary_variables.add(var)
+        return aux_map
+
     def add_constraint(self, ctc: Constraint) -> None:
-        def get_term_variable(term: Any) -> int:
-            if term.startswith('-'):
-                return -self.destination_model.get_variable(term[1:])
+        if self.cnf_method == 'tseytin':
+            clauses, aux_names = ctc.ast.get_clauses_with_aux(method='tseytin')
+            aux_map = self._allocate_auxiliary(aux_names)
+        else:
+            clauses = ctc.ast.get_clauses()
+            aux_map = {}
 
-            return self.destination_model.get_variable(term)
+        def get_term_variable(term: Any) -> int:
+            negated = term.startswith('-')
+            name = term[1:] if negated else term
+            var = aux_map[name] if name in aux_map else self.destination_model.get_variable(name)
+            return -var if negated else var
 
-        clauses = ctc.ast.get_clauses()
         for clause in clauses:
             clause_variables = list(map(get_term_variable, clause))
             self.destination_model.add_clause(clause_variables)

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5/flamapy_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-sat
-Version: 2.6.0.dev4
+Version: 2.6.0.dev5
 Summary: flamapy-sat is a plugin to flamapy module
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,8 +8,8 @@ Project-URL: Homepage, https://github.com/flamapy/pysat_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.6.0.dev4
-Requires-Dist: flamapy-fm~=2.6.0.dev4
+Requires-Dist: flamapy-fw~=2.6.0.dev5
+Requires-Dist: flamapy-fm~=2.6.0.dev5
 Requires-Dist: python-sat~=0.1.7.dev1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy_sat.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ flamapy/metamodels/pysat_diagnosis_metamodel/models/__init__.py
 flamapy/metamodels/pysat_diagnosis_metamodel/models/pysat_diagnosis_model.py
 flamapy/metamodels/pysat_diagnosis_metamodel/operations/__init__.py
 flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_abstract_identifier.py
+flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_configuration_diagnosis.py
 flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_conflict.py
 flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_diagnosis.py
 flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/__init__.py
@@ -28,6 +29,7 @@ flamapy/metamodels/pysat_metamodel/models/__init__.py
 flamapy/metamodels/pysat_metamodel/models/pysat_model.py
 flamapy/metamodels/pysat_metamodel/models/txtcnf_model.py
 flamapy/metamodels/pysat_metamodel/operations/__init__.py
+flamapy/metamodels/pysat_metamodel/operations/pysat_attribute_optimization.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_backbone.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_commonality.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_configurations.py
@@ -37,9 +39,11 @@ flamapy/metamodels/pysat_metamodel/operations/pysat_dead_features.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_false_optional_features.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_filter.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_metrics.py
+flamapy/metamodels/pysat_metamodel/operations/pysat_minimum_configuration.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_sampling.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_satisfiable.py
 flamapy/metamodels/pysat_metamodel/operations/pysat_satisfiable_configuration.py
+flamapy/metamodels/pysat_metamodel/operations/pysat_twise_sampling.py
 flamapy/metamodels/pysat_metamodel/transformations/__init__.py
 flamapy/metamodels/pysat_metamodel/transformations/cnf_to_pysat.py
 flamapy/metamodels/pysat_metamodel/transformations/dimacs_reader.py

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/flamapy_sat.egg-info/requires.txt

@@ -1,5 +1,5 @@
-flamapy-fw~=2.6.0.dev4
-flamapy-fm~=2.6.0.dev4
+flamapy-fw~=2.6.0.dev5
+flamapy-fm~=2.6.0.dev5
 python-sat~=0.1.7.dev1
 
 [dev]

{flamapy_sat-2.6.0.dev4 → flamapy_sat-2.6.0.dev5}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flamapy-sat"
-version = "2.6.0.dev4"
+version = "2.6.0.dev5"
 description = "flamapy-sat is a plugin to flamapy module"
 readme = "README.md"
 license = "GPL-3.0-or-later"
 authors = [{ name = "Flamapy", email = "flamapy@us.es" }]
 requires-python = ">=3.11"
 dependencies = [
-    "flamapy-fw~=2.6.0.dev4",
-    "flamapy-fm~=2.6.0.dev4",
+    "flamapy-fw~=2.6.0.dev5",
+    "flamapy-fm~=2.6.0.dev5",
     "python-sat~=0.1.7.dev1",
 ]
 

flamapy_sat-2.6.0.dev4/flamapy/metamodels/pysat_diagnosis_metamodel/operations/__init__.py

@@ -1,12 +0,0 @@
-# pylint: disable=cyclic-import
-
-from .pysat_abstract_identifier import PySATAbstractIdentifier
-from .pysat_conflict import PySATConflict
-from .pysat_diagnosis import PySATDiagnosis
-
-
-__all__ = [
-    'PySATAbstractIdentifier',
-    'PySATConflict',
-    'PySATDiagnosis'
-]