flamapy-sdd 2.6.0.dev11__tar.gz → 2.9.0.dev0__tar.gz

{flamapy_sdd-2.6.0.dev11 → flamapy_sdd-2.9.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-sdd
-Version: 2.6.0.dev11
+Version: 2.9.0.dev0
 Summary: flamapy-sdd is a plugin to flamapy providing Sentential Decision Diagram (SDD) knowledge compilation for exact analysis of feature models
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,8 +8,8 @@ Project-URL: Homepage, https://github.com/flamapy/sdd_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.6.0.dev11
-Requires-Dist: flamapy-fm~=2.6.0.dev11
+Requires-Dist: flamapy-fw~=2.9.0.dev0
+Requires-Dist: flamapy-fm~=2.9.0.dev0
 Requires-Dist: PySDD~=1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"

flamapy_sdd-2.9.0.dev0/flamapy/metamodels/sdd_metamodel/__init__.py

@@ -0,0 +1,24 @@
+from flamapy.core.manifest import OperationCapability, PluginManifest
+from flamapy.core.models.language_level import LanguageLevel, MajorLevel, MinorLevel
+
+# Costs are estimated milliseconds from the 2026-11-06 calibration (betty synthetic models at 1%
+# and 30% constraint density plus JHipster and busybox; worst case of the two densities, never
+# decreasing). Compilation depends on the constraint density far more than on the size: the
+# sparse models compile in 0.3 s up to 2,000 features, the dense 500-feature one takes 7.5 s and
+# the dense 1,000-feature one (like busybox, 1,108 features) does not finish in 5 minutes.
+# Counting is then immediate (66 ms at 500 features), but core/dead features condition the SDD
+# per variable: 41 s for core and more than 3 minutes for dead on the dense 500-feature model.
+MANIFEST = PluginManifest(
+    name='sdd',
+    calibration='2026-11-06',
+    extension='sdd',
+    supported_level=LanguageLevel(MajorLevel.BOOLEAN, {MinorLevel.GROUP_CARDINALITY}),
+    max_features=2000,
+    transformation_cost_curve=((50, 3), (100, 5), (200, 10), (500, 7500), (1000, 300000)),
+    operations={
+        'satisfiable': OperationCapability(cost=1),
+        'configurations_number': OperationCapability(cost_curve=((200, 1), (500, 66))),
+        'core_features': OperationCapability(cost_curve=((100, 1), (200, 5), (500, 41000))),
+        'dead_features': OperationCapability(cost_curve=((100, 1), (200, 4), (500, 180000))),
+    },
+)

{flamapy_sdd-2.6.0.dev11 → flamapy_sdd-2.9.0.dev0}/flamapy/metamodels/sdd_metamodel/operations/sdd_core_features.py

@@ -9,7 +9,8 @@ class SDDCoreFeatures(CoreFeatures):
     """Core features: present in every valid configuration.
 
     A feature is core iff no model selects it as false, i.e. conjoining its negative literal
-    with the compiled SDD yields the false node.
+    with the compiled SDD yields the false node. A void model has no core features (the
+    convention of the SAT and BDD plugins), not vacuously all of them.
     """
 
     def __init__(self) -> None:
@@ -24,7 +25,10 @@ class SDDCoreFeatures(CoreFeatures):
     def execute(self, model: VariabilityModel) -> 'SDDCoreFeatures':
         sdd_model = cast(SDDModel, model)
         manager = sdd_model.manager
-        core = []
+        core: list[Any] = []
+        if sdd_model.root.is_false():  # void model
+            self._result = core
+            return self
         for variable, name in sdd_model.features.items():
             if (sdd_model.root & manager.literal(-variable)).is_false():
                 core.append(name)

{flamapy_sdd-2.6.0.dev11 → flamapy_sdd-2.9.0.dev0}/flamapy/metamodels/sdd_metamodel/transformations/fm_to_sdd.py

@@ -1,7 +1,7 @@
 from pysdd.sdd import SddManager, Vtree
 
 from flamapy.core.transformations import ModelToModel
-from flamapy.metamodels.fm_metamodel.models import FeatureModel, ClauseSet
+from flamapy.metamodels.fm_metamodel.models import ClauseSet, DEFAULT_CNF_METHOD, FeatureModel
 from flamapy.metamodels.sdd_metamodel.models import SDDModel
 
 
@@ -20,7 +20,7 @@ class FmToSDD(ModelToModel):
     def get_destination_extension() -> str:
         return 'sdd'
 
-    def __init__(self, source_model: FeatureModel, cnf_method: str = 'distributive') -> None:
+    def __init__(self, source_model: FeatureModel, cnf_method: str = DEFAULT_CNF_METHOD) -> None:
         self.source_model = source_model
         self.cnf_method = cnf_method
         self.destination_model = SDDModel()

{flamapy_sdd-2.6.0.dev11 → flamapy_sdd-2.9.0.dev0}/flamapy_sdd.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-sdd
-Version: 2.6.0.dev11
+Version: 2.9.0.dev0
 Summary: flamapy-sdd is a plugin to flamapy providing Sentential Decision Diagram (SDD) knowledge compilation for exact analysis of feature models
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,8 +8,8 @@ Project-URL: Homepage, https://github.com/flamapy/sdd_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.6.0.dev11
-Requires-Dist: flamapy-fm~=2.6.0.dev11
+Requires-Dist: flamapy-fw~=2.9.0.dev0
+Requires-Dist: flamapy-fm~=2.9.0.dev0
 Requires-Dist: PySDD~=1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"

{flamapy_sdd-2.6.0.dev11 → flamapy_sdd-2.9.0.dev0}/flamapy_sdd.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ flamapy/metamodels/sdd_metamodel/transformations/fm_to_sdd.py
 flamapy_sdd.egg-info/PKG-INFO
 flamapy_sdd.egg-info/SOURCES.txt
 flamapy_sdd.egg-info/dependency_links.txt
+flamapy_sdd.egg-info/entry_points.txt
 flamapy_sdd.egg-info/requires.txt
 flamapy_sdd.egg-info/top_level.txt
 tests/test_sdd.py

flamapy_sdd-2.9.0.dev0/flamapy_sdd.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[flamapy.plugins]
+sdd = flamapy.metamodels.sdd_metamodel

{flamapy_sdd-2.6.0.dev11 → flamapy_sdd-2.9.0.dev0}/flamapy_sdd.egg-info/requires.txt

@@ -1,5 +1,5 @@
-flamapy-fw~=2.6.0.dev11
-flamapy-fm~=2.6.0.dev11
+flamapy-fw~=2.9.0.dev0
+flamapy-fm~=2.9.0.dev0
 PySDD~=1.0
 
 [dev]

{flamapy_sdd-2.6.0.dev11 → flamapy_sdd-2.9.0.dev0}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flamapy-sdd"
-version = "2.6.0.dev11"
+version = "2.9.0.dev0"
 description = "flamapy-sdd is a plugin to flamapy providing Sentential Decision Diagram (SDD) knowledge compilation for exact analysis of feature models"
 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.dev11",
-    "flamapy-fm~=2.6.0.dev11",
+    "flamapy-fw~=2.9.0.dev0",
+    "flamapy-fm~=2.9.0.dev0",
     "PySDD~=1.0",
 ]
 
@@ -25,6 +25,9 @@ dev = [
     "coverage",
 ]
 
+[project.entry-points."flamapy.plugins"]
+sdd = "flamapy.metamodels.sdd_metamodel"
+
 [project.urls]
 Homepage = "https://github.com/flamapy/sdd_metamodel"
 

flamapy_sdd-2.9.0.dev0/tests/test_sdd.py

@@ -0,0 +1,166 @@
+"""Tests for the SDD metamodel: exact counting, satisfiability, core/dead features.
+
+Oracles are computed by brute-forcing the CNF from fm_metamodel's solver-agnostic ClauseSet,
+so CI needs no SAT plugin — only flamapy-fm, which is already a declared dependency.
+"""
+import os
+import tempfile
+from itertools import product
+
+from flamapy.metamodels.fm_metamodel.transformations import UVLReader
+from flamapy.metamodels.fm_metamodel.models import FeatureModel, ClauseSet
+from flamapy.metamodels.sdd_metamodel.transformations import FmToSDD
+from flamapy.metamodels.sdd_metamodel.operations import (
+    SDDConfigurationsNumber,
+    SDDSatisfiable,
+    SDDCoreFeatures,
+    SDDDeadFeatures,
+)
+
+
+def _valid_configs(fm: FeatureModel) -> tuple:
+    """(valid configurations as frozensets of selected names, all feature names)."""
+    clause_set = ClauseSet.from_feature_model(fm)
+    name_of = {vid: name for name, vid in clause_set.variables.items()}
+    var_ids = sorted({abs(lit) for clause in clause_set.clauses for lit in clause}
+                     | set(clause_set.variables.values()))
+    configs = set()
+    for bits in product((False, True), repeat=len(var_ids)):
+        assignment = dict(zip(var_ids, bits))
+        if all(any((lit > 0) == assignment[abs(lit)] for lit in clause)
+               for clause in clause_set.clauses):
+            configs.add(frozenset(name_of[v] for v in var_ids if assignment[v] and v in name_of))
+    return configs, set(clause_set.variables)
+
+
+def _exact_count(fm: FeatureModel) -> int:
+    return len(_valid_configs(fm)[0])
+
+
+def _core_features(fm: FeatureModel) -> set:
+    configs, names = _valid_configs(fm)
+    return {name for name in names if configs and all(name in cfg for cfg in configs)}
+
+
+def _dead_features(fm: FeatureModel) -> set:
+    configs, names = _valid_configs(fm)
+    return names - (set().union(*configs) if configs else set())
+
+_UVL = """features
+    Root {abstract}
+        mandatory
+            Base
+        optional
+            A
+            B
+            C
+constraints
+    A => B
+    A | B
+"""
+
+_UNSAT_UVL = """features
+    Root {abstract}
+        mandatory
+            A
+constraints
+    !A
+"""
+
+
+def _fm(uvl):
+    handle, path = tempfile.mkstemp(suffix='.uvl')
+    try:
+        with os.fdopen(handle, 'w') as file:
+            file.write(uvl)
+        return UVLReader(path).transform()
+    finally:
+        os.remove(path)
+
+
+def test_count_matches_sat_enumeration():
+    fm = _fm(_UVL)
+    exact = _exact_count(fm)
+    sdd = SDDConfigurationsNumber().execute(FmToSDD(fm).transform()).get_result()
+    assert sdd == exact
+
+
+def test_satisfiable():
+    assert SDDSatisfiable().execute(FmToSDD(_fm(_UVL)).transform()).get_result() is True
+
+
+def test_unsatisfiable_model():
+    assert SDDSatisfiable().execute(FmToSDD(_fm(_UNSAT_UVL)).transform()).get_result() is False
+
+
+def test_core_features_match_sat():
+    fm = _fm(_UVL)
+    expected = _core_features(fm)
+    sdd = set(SDDCoreFeatures().execute(FmToSDD(fm).transform()).get_result())
+    assert sdd == expected
+    assert 'Base' in sdd and 'Root' in sdd  # mandatory chain is core
+
+
+def test_dead_features_match_sat():
+    fm = _fm(_UVL)
+    expected = _dead_features(fm)
+    sdd = set(SDDDeadFeatures().execute(FmToSDD(fm).transform()).get_result())
+    assert sdd == expected  # no dead features in this model
+
+
+def test_void_model_has_no_core_features():
+    fm = _fm(_UNSAT_UVL)
+    model = FmToSDD(fm).transform()
+    assert SDDCoreFeatures().execute(model).get_result() == []
+    assert set(SDDCoreFeatures().execute(model).get_result()) == _core_features(fm)
+    assert set(SDDDeadFeatures().execute(model).get_result()) == _dead_features(fm)
+
+
+_TSEYTIN_UVL = """features
+    Root {abstract}
+        optional
+            A
+            B
+            C
+            D
+            E
+            F
+constraints
+    (A & B & C) | (D & E & F) | (B & E & F)
+"""
+
+
+def test_cnf_methods_agree():
+    """Tseytin auxiliary variables must not change the count or the core/dead features.
+
+    The constraint is wide enough for 'auto' to choose Tseytin (27 distributive clauses).
+    """
+    fm = _fm(_TSEYTIN_UVL)
+    assert ClauseSet.from_feature_model(fm, cnf_method='auto').auxiliary_variables
+    expected = (_exact_count(fm), _core_features(fm), _dead_features(fm))
+    for method in ('distributive', 'tseytin', 'auto'):
+        model = FmToSDD(fm, cnf_method=method).transform()
+        got = (SDDConfigurationsNumber().execute(model).get_result(),
+               set(SDDCoreFeatures().execute(model).get_result()),
+               set(SDDDeadFeatures().execute(model).get_result()))
+        assert got == expected, method
+
+
+# [1..2] over A, B, C (3 + 3 selections) times D optional: 12 configurations.
+_GROUP_UVL = """features
+    Root {abstract}
+        [1..2]
+            A
+            B
+            C
+        optional
+            D
+"""
+
+
+def test_group_cardinality():
+    fm = _fm(_GROUP_UVL)
+    model = FmToSDD(fm).transform()
+    assert SDDConfigurationsNumber().execute(model).get_result() == 12
+    assert set(SDDCoreFeatures().execute(model).get_result()) == _core_features(fm) == {'Root'}
+    assert set(SDDDeadFeatures().execute(model).get_result()) == _dead_features(fm) == set()

flamapy_sdd-2.6.0.dev11/tests/test_sdd.py

@@ -1,82 +0,0 @@
-"""Tests for the SDD metamodel: exact counting, satisfiability, core/dead features.
-
-Oracles come from the SAT backend (a declared dependency) so CI needs no extra plugin.
-"""
-import os
-import tempfile
-
-from flamapy.metamodels.fm_metamodel.transformations import UVLReader
-from flamapy.metamodels.sdd_metamodel.transformations import FmToSDD
-from flamapy.metamodels.sdd_metamodel.operations import (
-    SDDConfigurationsNumber,
-    SDDSatisfiable,
-    SDDCoreFeatures,
-    SDDDeadFeatures,
-)
-from flamapy.metamodels.pysat_metamodel.transformations import FmToPysat
-from flamapy.metamodels.pysat_metamodel.operations.pysat_configurations_number import (
-    PySATConfigurationsNumber,
-)
-from flamapy.metamodels.pysat_metamodel.operations.pysat_core_features import PySATCoreFeatures
-from flamapy.metamodels.pysat_metamodel.operations.pysat_dead_features import PySATDeadFeatures
-
-_UVL = """features
-    Root {abstract}
-        mandatory
-            Base
-        optional
-            A
-            B
-            C
-constraints
-    A => B
-    A | B
-"""
-
-_UNSAT_UVL = """features
-    Root {abstract}
-        mandatory
-            A
-constraints
-    !A
-"""
-
-
-def _fm(uvl):
-    handle, path = tempfile.mkstemp(suffix='.uvl')
-    try:
-        with os.fdopen(handle, 'w') as file:
-            file.write(uvl)
-        return UVLReader(path).transform()
-    finally:
-        os.remove(path)
-
-
-def test_count_matches_sat_enumeration():
-    fm = _fm(_UVL)
-    exact = PySATConfigurationsNumber().execute(FmToPysat(fm).transform()).get_result()
-    sdd = SDDConfigurationsNumber().execute(FmToSDD(fm).transform()).get_result()
-    assert sdd == exact
-
-
-def test_satisfiable():
-    assert SDDSatisfiable().execute(FmToSDD(_fm(_UVL)).transform()).get_result() is True
-
-
-def test_unsatisfiable_model():
-    assert SDDSatisfiable().execute(FmToSDD(_fm(_UNSAT_UVL)).transform()).get_result() is False
-
-
-def test_core_features_match_sat():
-    fm = _fm(_UVL)
-    sat = set(PySATCoreFeatures().execute(FmToPysat(fm).transform()).get_result())
-    sdd = set(SDDCoreFeatures().execute(FmToSDD(fm).transform()).get_result())
-    assert sdd == sat
-    assert 'Base' in sdd and 'Root' in sdd  # mandatory chain is core
-
-
-def test_dead_features_match_sat():
-    fm = _fm(_UVL)
-    sat = set(PySATDeadFeatures().execute(FmToPysat(fm).transform()).get_result())
-    sdd = set(SDDDeadFeatures().execute(FmToSDD(fm).transform()).get_result())
-    assert sdd == sat  # no dead features in this model