flamapy-z3 2.5.0.dev0__tar.gz → 2.6.0__tar.gz

flamapy_z3-2.6.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: flamapy-z3
+Version: 2.6.0
+Summary: z3-plugin for the automated analysis of feature models
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/z3_metamodel
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: flamapy-fw~=2.6.0
+Requires-Dist: flamapy-fm~=2.6.0
+Requires-Dist: z3-solver~=4.14.1.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: prospector; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+
+# flamapy-z3
+
+SMT-based analysis for [flamapy](https://flamapy.org) feature models with typed
+attributes (Integer, Real, String), built on the [Z3](https://github.com/Z3Prover/z3)
+solver.
+
+**Documentation:** https://docs.flamapy.org/framework/plugins/z3_plugin
+
+## Installation
+
+```bash
+pip install flamapy-z3
+```

flamapy_z3-2.6.0/README.md

@@ -0,0 +1,13 @@
+# flamapy-z3
+
+SMT-based analysis for [flamapy](https://flamapy.org) feature models with typed
+attributes (Integer, Real, String), built on the [Z3](https://github.com/Z3Prover/z3)
+solver.
+
+**Documentation:** https://docs.flamapy.org/framework/plugins/z3_plugin
+
+## Installation
+
+```bash
+pip install flamapy-z3
+```

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/models/z3_model.py

@@ -35,6 +35,9 @@ class Z3Model(VariabilityModel):
         self.attributes: dict[str, list[Any]] = {}  # attr_name -> [z3var]
         self.attributes_types: dict[str, AttributeType] = {}  # attr_name -> AttributeType
         self.constraints: list[Any] = []  # list of z3 expressions
+        # Auxiliary (Tseytin) boolean variables. Kept out of ``features`` so that feature
+        # enumeration/counting/bounds operations ignore them.
+        self.auxiliary_variables: list[Any] = []
         self.original_model: Optional[VariabilityModel] = None
 
     def create_const(self, ftype: FeatureType | AttributeType, value: Any) -> Any:

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/operations/__init__.py

@@ -1,6 +1,7 @@
 from .z3_satisfiable import Z3Satisfiable
 from .z3_configurations import Z3Configurations
 from .z3_configurations_number import Z3ConfigurationsNumber
+from .z3_backbone import Z3Backbone
 from .z3_core_features import Z3CoreFeatures
 from .z3_dead_features import Z3DeadFeatures
 from .z3_false_optional_features import Z3FalseOptionalFeatures
@@ -9,9 +10,11 @@ from .z3_satisfiable_configuration import Z3SatisfiableConfiguration
 from .z3_feature_bounds import Z3FeatureBounds
 from .z3_all_feature_bounds import Z3AllFeatureBounds
 
+
 __all__ = [
            'Z3AllFeatureBounds',
            'Z3AttributeOptimization',
+           'Z3Backbone',
            'Z3Configurations',
            'Z3ConfigurationsNumber',
            'Z3CoreFeatures',

flamapy_z3-2.6.0/flamapy/metamodels/z3_metamodel/operations/interfaces/attribute_optimization.py

@@ -0,0 +1,12 @@
+"""Backward-compatible re-export.
+
+``AttributeOptimization`` and ``OptimizationGoal`` now live in the core framework so
+that every backend shares one interface. This module keeps the historical import path
+``flamapy.metamodels.z3_metamodel.operations.interfaces.attribute_optimization`` working.
+"""
+from flamapy.core.operations.attribute_optimization import (
+    AttributeOptimization,
+    OptimizationGoal,
+)
+
+__all__ = ["AttributeOptimization", "OptimizationGoal"]

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/operations/z3_all_feature_bounds.py

@@ -3,6 +3,7 @@ from typing import Any, cast
 
 from flamapy.core.models import VariabilityModel
 from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor
 from flamapy.metamodels.z3_metamodel.models import Z3Model
 from flamapy.metamodels.z3_metamodel.operations import Z3FeatureBounds
 from flamapy.metamodels.fm_metamodel.models import FeatureType
@@ -16,6 +17,16 @@ class Z3AllFeatureBounds(Operation):
     (Integer, Real, String length) in the Z3 model.
     """
 
+    facade = OperationDescriptor(
+        doc=(
+            'Returns the value bounds for all typed (Integer, Real, String) attribute\n'
+            "features in the model. Each entry maps a feature name to a dict with 'min',\n"
+            "'max', and 'bounded' keys. Requires the z3 metamodel plugin."
+        ),
+        returns='Union[None, Dict[str, Dict[str, Any]]]',
+        name='all_feature_bounds', operation='Z3AllFeatureBounds', default_backend='z3'
+    )
+
     def __init__(self) -> None:
         # El resultado será un diccionario donde la clave es el nombre de la variable
         # y el valor es el diccionario de bounds (min, max, bounded).

flamapy_z3-2.6.0/flamapy/metamodels/z3_metamodel/operations/z3_backbone.py

@@ -0,0 +1,70 @@
+from typing import Any, cast
+
+import z3
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.metamodels.z3_metamodel.models import Z3Model
+
+
+class Z3Backbone(Operation):
+
+    def __init__(self) -> None:
+        self._result: dict[str, list[Any]] = {"core": [], "dead": []}
+
+    def get_backbone(self) -> dict[str, list[Any]]:
+        return self.get_result()
+
+    def get_result(self) -> dict[str, list[Any]]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'Z3Backbone':
+        z3_model = cast(Z3Model, model)
+        self._result = get_backbone(z3_model)
+        return self
+
+
+def get_backbone(model: Z3Model) -> dict[str, list[Any]]:
+    solver = z3.Solver(ctx=model.ctx)
+    solver.add(model.constraints)
+
+    vars_to_features = {f_info.sel: name for name, f_info in model.features.items()}
+
+    # (out, C) <- SAT(phi)
+    if solver.check() != z3.sat:
+        return {"core": [], "dead": list(model.features.keys())}
+
+    m = solver.model()
+    # C <- filter(C)
+    core_candidates = {var for var in vars_to_features.keys() if z3.is_true(m[var])}
+    dead_candidates = {var for var in vars_to_features.keys() if z3.is_false(m[var])}
+
+    backbone_core = []
+    backbone_dead = []
+
+    while core_candidates or dead_candidates:
+        if core_candidates:
+            literal = next(iter(core_candidates))
+            check_lit = z3.Not(literal)
+            is_core = True
+        else:
+            literal = next(iter(dead_candidates))
+            check_lit = literal
+            is_core = False
+
+        # (out, S) <- SAT(phi U {not l})
+        if solver.check([check_lit]) == z3.unsat:
+            if is_core:
+                backbone_core.append(vars_to_features[literal])
+                solver.add(literal)
+                core_candidates.remove(literal)
+            else:
+                backbone_dead.append(vars_to_features[literal])
+                solver.add(z3.Not(literal))
+                dead_candidates.remove(literal)
+        else:
+            new_model = solver.model()
+            core_candidates = {var for var in core_candidates if z3.is_true(new_model[var])}
+            dead_candidates = {var for var in dead_candidates if z3.is_false(new_model[var])}
+
+    return {"core": backbone_core, "dead": backbone_dead}

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/operations/z3_core_features.py

@@ -1,10 +1,9 @@
 from typing import Any, cast
 
-import z3
-
 from flamapy.core.models import VariabilityModel
 from flamapy.core.operations import CoreFeatures
 from flamapy.metamodels.z3_metamodel.models import Z3Model
+from flamapy.metamodels.z3_metamodel.operations import Z3Backbone
 
 
 class Z3CoreFeatures(CoreFeatures):
@@ -20,18 +19,5 @@ class Z3CoreFeatures(CoreFeatures):
 
     def execute(self, model: VariabilityModel) -> 'Z3CoreFeatures':
         z3_model = cast(Z3Model, model)
-        self._result = get_core_features(z3_model)
+        self._result = Z3Backbone().execute(z3_model).get_result()["core"]
         return self
-
-
-def get_core_features(model: Z3Model) -> list[Any]:
-    solver = z3.Solver(ctx=model.ctx)
-    solver.add(model.constraints)
-
-    core_features = []
-    if solver.check() == z3.sat:
-        for feature, feature_info in model.features.items():
-            variable = feature_info.sel
-            if solver.check([z3.Not(variable)]) == z3.unsat:
-                core_features.append(feature)
-    return core_features

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/operations/z3_dead_features.py

@@ -1,10 +1,9 @@
 from typing import Any, cast
 
-import z3
-
 from flamapy.core.models import VariabilityModel
 from flamapy.core.operations import DeadFeatures
 from flamapy.metamodels.z3_metamodel.models import Z3Model
+from flamapy.metamodels.z3_metamodel.operations import Z3Backbone
 
 
 class Z3DeadFeatures(DeadFeatures):
@@ -20,18 +19,5 @@ class Z3DeadFeatures(DeadFeatures):
 
     def execute(self, model: VariabilityModel) -> 'Z3DeadFeatures':
         z3_model = cast(Z3Model, model)
-        self._result = get_dead_features(z3_model)
+        self._result = Z3Backbone().execute(z3_model).get_result()["dead"]
         return self
-
-
-def get_dead_features(model: Z3Model) -> list[Any]:
-    solver = z3.Solver(ctx=model.ctx)
-    solver.add(model.constraints)
-
-    dead_features = []
-    if solver.check() == z3.sat:
-        for feature, feature_info in model.features.items():
-            variable = feature_info.sel
-            if solver.check([variable]) == z3.unsat:
-                dead_features.append(feature)
-    return dead_features

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/operations/z3_false_optional_features.py

@@ -10,7 +10,7 @@ from flamapy.metamodels.fm_metamodel.models import FeatureModel
 from flamapy.metamodels.z3_metamodel.models import Z3Model
 
 
-LOGGER = logging.getLogger('PySATFalseOptionalFeatures')
+LOGGER = logging.getLogger('Z3FalseOptionalFeatures')
 
 
 class Z3FalseOptionalFeatures(FalseOptionalFeatures):
@@ -26,11 +26,11 @@ class Z3FalseOptionalFeatures(FalseOptionalFeatures):
 
     def execute(self, model: VariabilityModel) -> 'Z3FalseOptionalFeatures':
         z3_model = cast(Z3Model, model)
-        try:
-            feature_model = cast(FeatureModel, model.original_model)
-        except FlamaException:
-            LOGGER.exception("The transformation didn't attach the source model, "
-                             "which is required for this operation.")
+        original_model = getattr(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)
         self._result = get_false_optional_features(z3_model, feature_model)
         return self
 

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/operations/z3_feature_bounds.py

@@ -5,6 +5,7 @@ import z3
 
 from flamapy.core.models import VariabilityModel
 from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor, Input
 from flamapy.metamodels.z3_metamodel.models import Z3Model
 from flamapy.metamodels.fm_metamodel.models import FeatureType
 
@@ -20,6 +21,17 @@ class Z3FeatureBounds(Operation):
     and the length bounds (min_len/max_len) for string features, with safety checks.
     """
 
+    facade = OperationDescriptor(
+        doc=(
+            'Returns the value bounds for a specific typed attribute feature. The result\n'
+            "dict contains 'min', 'max', and 'bounded' keys. Requires the z3 metamodel\n"
+            'plugin.'
+        ),
+        returns='Union[None, Dict[str, Any]]',
+        name='feature_bounds', operation='Z3FeatureBounds', default_backend='z3',
+        inputs=(Input('variable_name', str, required=True, setter='set_variable_name'),),
+    )
+
     def __init__(self) -> None:
         self._result: dict[str, Any] = {}
         self._variable_name: Optional[str] = None

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy/metamodels/z3_metamodel/transformations/fm_to_z3.py

@@ -61,10 +61,16 @@ class FmToZ3(ModelToModel):
     def get_destination_extension() -> str:
         return "z3"
 
-    def __init__(self, source_model: FeatureModel) -> None:
+    def __init__(self, source_model: FeatureModel, cnf_method: str = 'direct') -> None:
         self.source_model = source_model
         self.destination_model: Z3Model = Z3Model()
         self._counter: int = 0
+        # 'direct' (default) builds Z3 boolean expressions straight from the AST. 'tseytin'
+        # applies the Tseytin CNF encoding to purely propositional boolean constraints
+        # (others fall back to 'direct'). Framework-only opt-in; Z3 already clausifies
+        # internally, so this exists for cross-backend uniformity/experimentation, not speed.
+        self.cnf_method = cnf_method
+        self._aux_counter: int = 0
 
     def transform(self) -> Z3Model:
         self.destination_model = Z3Model()
@@ -195,7 +201,6 @@ class FmToZ3(ModelToModel):
         self.destination_model.add_constraint(formula)
 
     def _add_mutex_formula(self, relation: Relation) -> None:
-        formulas = []
         parent_variable = self.destination_model.get_variable(relation.parent.name)
         if parent_variable is None:
             raise FlamaException(f'Unsupported feature: {relation.parent.name}')
@@ -206,12 +211,13 @@ class FmToZ3(ModelToModel):
             if child_variable is None:
                 raise FlamaException(f'Unsupported feature: {child.name}')
             children.add(child_variable.sel)
+        one_child_formula = []
         for child in children:
-            children_negatives = children - {child}
-            formula = (child == z3.And([z3.Not(ch) for ch in children_negatives] + [parent]))
-            formulas.append(formula)
-        formula = z3.And(*formulas)
-        formula = z3.Or(parent == z3.Not(z3.Or(*children)), formula)
+            other_children_or = z3.Or(*list(children - {child}))
+            one_child_formula.append(z3.Not(child) == other_children_or)
+        one_child_formula = z3.And(*one_child_formula)
+        no_child_formula = z3.And(*[z3.Not(ch) for ch in children])
+        formula = z3.Or(no_child_formula, z3.And(one_child_formula, parent))
         self.destination_model.add_constraint(formula)
 
     def _build_literals(self, children: list[Any], combination: tuple[Any, ...]) -> list[Any]:
@@ -258,9 +264,54 @@ class FmToZ3(ModelToModel):
         self._add_inactive_parent_constraints(parent, children)
 
     def _add_constraint_formula(self, ctc: Constraint) -> None:
+        if self.cnf_method == 'tseytin' and self._is_propositional_boolean(ctc):
+            self._add_tseytin_constraint(ctc)
+            return
         expr = self._get_expression(ctc.ast.root, None)
         self.destination_model.add_constraint(expr)
 
+    def _is_propositional_boolean(self, ctc: Constraint) -> bool:
+        """Whether a constraint is purely propositional over boolean features, i.e. safe
+        for the Tseytin CNF encoding. Arithmetic/aggregation/typed constraints are not."""
+        if any(op not in LOGICAL_OPERATORS for op in ctc.ast.get_operators()):
+            return False
+        for operand in ctc.ast.get_operands():
+            if not isinstance(operand, str):
+                return False
+            info = self.destination_model.get_variable(operand)
+            if info is None or info.ftype != FeatureType.BOOLEAN:
+                return False
+        return True
+
+    def _add_tseytin_constraint(self, ctc: Constraint) -> None:
+        clauses, aux_names = ctc.ast.get_clauses_with_aux(method='tseytin')
+        ctx = self.destination_model.ctx
+        # Fresh, globally-unique Z3 Bool per auxiliary name (same-named Bools in one Z3
+        # context are the same variable, so per-constraint names must not collide).
+        local: dict[str, Any] = {}
+        for name in aux_names:
+            self._aux_counter += 1
+            aux_var = z3.Bool(f'__tseytin_aux_{self._aux_counter}', ctx=ctx)
+            local[name] = aux_var
+            self.destination_model.auxiliary_variables.append(aux_var)
+
+        def literal_expr(term: str) -> Any:
+            negated = term.startswith('-')
+            name = term[1:] if negated else term
+            if name in local:
+                expr = local[name]
+            else:
+                info = self.destination_model.get_variable(name)
+                if info is None:
+                    raise FlamaException(f'Unsupported feature: {name}')
+                expr = info.sel
+            return z3.Not(expr) if negated else expr
+
+        for clause in clauses:
+            literals = [literal_expr(term) for term in clause]
+            formula = literals[0] if len(literals) == 1 else z3.Or(*literals)
+            self.destination_model.add_constraint(formula)
+
     def _get_expression(self, node: Node, parent: Optional[Node]) -> z3.ExprRef:
         if node.is_term():
             return self._get_term_expression(node, parent)

flamapy_z3-2.6.0/flamapy_z3.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: flamapy-z3
+Version: 2.6.0
+Summary: z3-plugin for the automated analysis of feature models
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/z3_metamodel
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: flamapy-fw~=2.6.0
+Requires-Dist: flamapy-fm~=2.6.0
+Requires-Dist: z3-solver~=4.14.1.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: prospector; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+
+# flamapy-z3
+
+SMT-based analysis for [flamapy](https://flamapy.org) feature models with typed
+attributes (Integer, Real, String), built on the [Z3](https://github.com/Z3Prover/z3)
+solver.
+
+**Documentation:** https://docs.flamapy.org/framework/plugins/z3_plugin
+
+## Installation
+
+```bash
+pip install flamapy-z3
+```

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy_z3.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ flamapy/metamodels/z3_metamodel/models/z3_model.py
 flamapy/metamodels/z3_metamodel/operations/__init__.py
 flamapy/metamodels/z3_metamodel/operations/z3_all_feature_bounds.py
 flamapy/metamodels/z3_metamodel/operations/z3_attribute_optimization.py
+flamapy/metamodels/z3_metamodel/operations/z3_backbone.py
 flamapy/metamodels/z3_metamodel/operations/z3_configurations.py
 flamapy/metamodels/z3_metamodel/operations/z3_configurations_number.py
 flamapy/metamodels/z3_metamodel/operations/z3_core_features.py
@@ -25,4 +26,5 @@ flamapy_z3.egg-info/SOURCES.txt
 flamapy_z3.egg-info/dependency_links.txt
 flamapy_z3.egg-info/requires.txt
 flamapy_z3.egg-info/top_level.txt
+tests/test_tseytin.py
 tests/test_z3_metamodel.py

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/flamapy_z3.egg-info/requires.txt

@@ -1,5 +1,5 @@
-flamapy-fw~=2.5.0.dev0
-flamapy-fm~=2.5.0.dev0
+flamapy-fw~=2.6.0
+flamapy-fm~=2.6.0
 z3-solver~=4.14.1.0
 
 [dev]

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flamapy-z3"
-version = "2.5.0.dev0"
+version = "2.6.0"
 description = "z3-plugin for the automated analysis of feature models"
 readme = "README.md"
 license = "GPL-3.0-or-later"
 authors = [{ name = "Flamapy", email = "flamapy@us.es" }]
-requires-python = ">=3.9"
+requires-python = ">=3.11"
 dependencies = [
-    "flamapy-fw~=2.5.0.dev0",
-    "flamapy-fm~=2.5.0.dev0",
+    "flamapy-fw~=2.6.0",
+    "flamapy-fm~=2.6.0",
     "z3-solver~=4.14.1.0",
 ]
 
@@ -33,7 +33,7 @@ include = ["flamapy.*"]
 
 [tool.ruff]
 line-length = 100
-target-version = "py39"
+target-version = "py311"
 
 [tool.ruff.lint]
 select = ["E", "W", "F", "C", "PL", "RUF"]

flamapy_z3-2.6.0/tests/test_tseytin.py

@@ -0,0 +1,69 @@
+"""The opt-in Tseytin CNF encoding must yield the same Z3 analysis results as the
+default direct translation, and must fall back to the direct translation for any
+constraint that is not purely propositional over boolean features."""
+import os
+import tempfile
+
+from flamapy.metamodels.fm_metamodel.transformations import UVLReader
+from flamapy.metamodels.z3_metamodel.transformations import FmToZ3
+from flamapy.metamodels.z3_metamodel.operations.z3_satisfiable import Z3Satisfiable
+from flamapy.metamodels.z3_metamodel.operations.z3_configurations import Z3Configurations
+from flamapy.metamodels.z3_metamodel.operations.z3_configurations_number import (
+    Z3ConfigurationsNumber,
+)
+
+
+# Purely propositional model: every cross-tree constraint is boolean.
+_PROP_UVL = """features
+    Root {abstract}
+        optional
+            A
+            B
+            C
+            D
+constraints
+    (A | B) => (C <=> D)
+    A => !B
+"""
+
+# All-arithmetic constraints; the Tseytin path must fall back to direct translation.
+_ARITH_MODEL = 'resources/models/uvl_models/fm03_integer_conditional_bounded.uvl'
+
+
+def _build_from_uvl_text(text, cnf_method):
+    handle, path = tempfile.mkstemp(suffix='.uvl')
+    try:
+        with os.fdopen(handle, 'w') as file:
+            file.write(text)
+        return FmToZ3(UVLReader(path).transform(), cnf_method=cnf_method).transform()
+    finally:
+        os.remove(path)
+
+
+def _projected(model):
+    configs = Z3Configurations().execute(model).get_result()
+    return {frozenset(k for k, v in c.elements.items() if v is True) for c in configs}
+
+
+def test_tseytin_matches_direct_on_propositional_model() -> None:
+    direct = _build_from_uvl_text(_PROP_UVL, 'direct')
+    tseytin = _build_from_uvl_text(_PROP_UVL, 'tseytin')
+
+    assert Z3ConfigurationsNumber().execute(direct).get_result() == \
+        Z3ConfigurationsNumber().execute(tseytin).get_result()
+    assert _projected(direct) == _projected(tseytin)
+    assert tseytin.auxiliary_variables  # gates were introduced
+    # Auxiliary variables must not have been registered as features.
+    assert not set(str(a) for a in tseytin.auxiliary_variables) & set(tseytin.features.keys())
+
+
+def test_tseytin_falls_back_for_arithmetic_constraints() -> None:
+    direct = FmToZ3(UVLReader(_ARITH_MODEL).transform(), cnf_method='direct').transform()
+    tseytin = FmToZ3(UVLReader(_ARITH_MODEL).transform(), cnf_method='tseytin').transform()
+
+    # Nothing was propositional, so no auxiliary variables were created.
+    assert tseytin.auxiliary_variables == []
+    assert Z3Satisfiable().execute(direct).get_result() == \
+        Z3Satisfiable().execute(tseytin).get_result()
+    assert Z3ConfigurationsNumber().execute(direct).get_result() == \
+        Z3ConfigurationsNumber().execute(tseytin).get_result()

{flamapy_z3-2.5.0.dev0 → flamapy_z3-2.6.0}/tests/test_z3_metamodel.py

@@ -53,7 +53,8 @@ def test_z3_satisfiable(path: str, expected: bool):
     ('resources/models/uvl_models/fm09_real_bounded.uvl', 6),
     ('resources/models/uvl_models/fm10_real_conditional_bounded.uvl', 3),
     ('resources/models/uvl_models/icecream_attributes.uvl', 15),
-    ('resources/models/uvl_models/group_cardinalities.uvl', 16)
+    ('resources/models/uvl_models/group_cardinalities.uvl', 16),
+    ('resources/models/uvl_models/mutex.uvl', 6)
 ])
 def test_nconfigs(path: str, expected: int):
     z3_model = _read_model(path)

flamapy_z3-2.5.0.dev0/PKG-INFO

@@ -1,202 +0,0 @@
-Metadata-Version: 2.4
-Name: flamapy-z3
-Version: 2.5.0.dev0
-Summary: z3-plugin for the automated analysis of feature models
-Author-email: Flamapy <flamapy@us.es>
-License-Expression: GPL-3.0-or-later
-Project-URL: Homepage, https://github.com/flamapy/z3_metamodel
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: flamapy-fw~=2.5.0.dev0
-Requires-Dist: flamapy-fm~=2.5.0.dev0
-Requires-Dist: z3-solver~=4.14.1.0
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-mock; extra == "dev"
-Requires-Dist: prospector; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: coverage; extra == "dev"
-
-# Automated Analysis of UVL using Satisfiability Modulo Theories
-
-
-## Description
-This repository contains the plugin that supports z3 representations for feature models.
-
-The plugin is based on [flamapy](https://flamapy.github.io/), and relies on the [Z3 solver](https://github.com/Z3Prover/z3?tab=readme-ov-file) library. The architecture is as follows:
-
-<p align="center">
-  <img width="750" src="resources/images/z3metamodel.png">
-</p>
-
-
-## Requirements and Installation
-- [Python 3.11+](https://www.python.org/)
-- [Flamapy](https://www.flamapy.org/)
-
-The framework has been tested in Linux and Windows 11 with Python 3.12. Python 3.13+ may not be still supported.
-
-### Download and installation
-1. Install [Python 3.11+](https://www.python.org/).
-2. Download/Clone this repository and enter into the main directory.
-3. Create a virtual environment: `python -m venv env`
-4. Activate the environment: 
-   
-   In Linux: `source env/bin/activate`
-
-   In Windows: `.\env\Scripts\Activate`
-
-5. Install dependencies (flamapy): `pip install -r requirements.txt`
-     
-    ** In case that you are running Ubuntu and get an error installing flamapy, please install the package python3-dev with the command `sudo apt update && sudo apt install python3-dev` and update wheel and setuptools with the command `pip  install --upgrade pip wheel setuptools` before step 5.
-
-
-## Functionality and usage
-The executable script [test.py](/test.py) serves as an entry point to show the plugin in action.
-
-Simply run: `python test.py` to see it in action over the running feature model presented in the paper.
-
-The following functionality is provided:
-
-
-### Load a feature model in UVL and translate to SMT
-```python
-from flamapy.metamodels.fm_metamodel.transformations import UVLReader
-from flamapy.metamodels.z3_metamodel.transformations import FmToZ3
-
-# Load the feature model from UVL
-fm_model = UVLReader('resources/models/uvl_models/Pizza_z3.uvl').transform()
-# Transform the feature model to SMT
-z3_model = FmToZ3(fm_model).transform()
-```
-
-### Analysis operations
-The following operations are available:
-```python
-from flamapy.metamodels.z3_metamodel.operations import (
-    Z3Satisfiable,
-    Z3Configurations,
-    Z3ConfigurationsNumber,
-    Z3CoreFeatures,
-    Z3DeadFeatures,
-    Z3FalseOptionalFeatures,
-    Z3AttributeOptimization,
-    Z3SatisfiableConfiguration,
-    Z3FeatureBounds,
-    Z3AllFeatureBounds,
-)
-```
-
-- **Satisfiable**
-
-    Return whether the model is satisfiable (valid):
-    ```python
-    satisfiable = Z3Satisfiable().execute(z3_model).get_result()
-    print(f'Satisfiable? (valid?): {satisfiable}')
-    ```
-
-- **Core features**
-
-    Return the core features of the model:
-    ```python
-    core_features = Z3CoreFeatures().execute(z3_model).get_result()
-    print(f'Core features: {core_features}')
-    ```
-
-- **Dead features**
-
-    Return the dead features of the model:
-    ```python
-    dead_features = Z3DeadFeatures().execute(z3_model).get_result()
-    print(f'Dead features: {dead_features}')
-    ```
-
-- **False-Optional features**
-
-    Return the false-optional features of the model:
-    ```python
-    false_optional_features = Z3FalseOptionalFeatures().execute(z3_model).get_result()
-    print(f'False-optional features: {false_optional_features}')
-    ```    
-
-- **Configurations**
-
-    Enumerate the configurations of the model:
-    ```python
-    configurations = Z3Configurations().execute(z3_model).get_result()
-    print(f'Configurations: {len(configurations)}')
-    for i, config in enumerate(configurations, 1):
-        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
-        print(f'Config. {i}: {config_str}')
-    ```
-
-- **Configurations number**
-
-    Return the number of configurations:
-    ```python
-    n_configs = Z3ConfigurationsNumber().execute(z3_model).get_result()
-    print(f'Configurations number: {n_configs}')
-    ```
-
-- **Boundaries analysis of typed features**
-
-    Return the boundaries of the numerical features (Integer, Real, String) of the model:
-    ```python
-    attributes = fm_model.get_attributes()
-    print('Attributes in the model')
-    for attr in attributes:
-        print(f' - {attr.name} ({attr.attribute_type})')
-    
-    variable_bounds = Z3AllFeatureBounds().execute(z3_model).get_result()
-    print('Variable bounds for all typed variables:')
-    for var_name, bounds in variable_bounds.items():
-        print(f' - {var_name}: {bounds}')
-    ```    
-
-- **Configuration optimization based on feature attributes:**
-
-    Return the set of configurations that optimize the given goals (i.e., the pareto front):
-    ```python
-    attribute_optimization_op = Z3AttributeOptimization()
-    attributes = {'Price': OptimizationGoal.MAXIMIZE,
-                  'Kcal': OptimizationGoal.MINIMIZE}
-    attribute_optimization_op.set_attributes(attributes)
-    configurations_with_values = attribute_optimization_op.execute(z3_model).get_result()
-    print(f'Optimum configurations: {len(configurations_with_values)} configs.')
-    for i, config_value in enumerate(configurations_with_values, 1):
-        config, values = config_value
-        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
-        values_str = ', '.join(f'{k}={v}' for k,v in values.items())
-        print(f'Config. {i}: {config_str} | Values: {values_str}')
-    ```    
-
-- Configuration validation:
-
-    Return whether a given partial or full configuration is valid:
-    ```python
-    from flamapy.metamodels.configuration_metamodel.transformations import ConfigurationJSONReader
-    configuration = ConfigurationJSONReader('resources/configs/pizza_z3_config1.json').transform()
-    configuration.set_full(False)
-    print(f'Configuration: {configuration.elements}')
-    satisfiable_configuration_op = Z3SatisfiableConfiguration()
-    satisfiable_configuration_op.set_configuration(configuration)
-    is_satisfiable = satisfiable_configuration_op.execute(z3_model).get_result()
-    print(f'Is the configuration satisfiable? {is_satisfiable}')
-    ```    
-
-**Note:** The Z3Configurations and Z3ConfigurationsNumber operations may takes longer if the number of configuration is huge, or even not finish if the model is unbounded.
-
-**Note:** The Z3Configurations and Z3ConfigurationsNumber operations support also a partial configuration as an additional argument, so the operation will return the result taking into account the given partial configuration. 
-For example:
-
-```python
-from flamapy.core.models import Configuration
-# Create a partial configuration
-elements = {'Pizza': True, 'SpicyLvl': 5}
-partial_config = Configuration(elements)
-# Calculate the number of configuration from the partial configuration
-configs_number_op = Z3ConfigurationsNumber()
-configs_number_op.set_partial_configuration(partial_config)
-n_configs = configs_number_op.execute(z3_model).get_result()
-print(f'#Configurations: {n_configs}')
-```

flamapy_z3-2.5.0.dev0/README.md

@@ -1,183 +0,0 @@
-# Automated Analysis of UVL using Satisfiability Modulo Theories
-
-
-## Description
-This repository contains the plugin that supports z3 representations for feature models.
-
-The plugin is based on [flamapy](https://flamapy.github.io/), and relies on the [Z3 solver](https://github.com/Z3Prover/z3?tab=readme-ov-file) library. The architecture is as follows:
-
-<p align="center">
-  <img width="750" src="resources/images/z3metamodel.png">
-</p>
-
-
-## Requirements and Installation
-- [Python 3.11+](https://www.python.org/)
-- [Flamapy](https://www.flamapy.org/)
-
-The framework has been tested in Linux and Windows 11 with Python 3.12. Python 3.13+ may not be still supported.
-
-### Download and installation
-1. Install [Python 3.11+](https://www.python.org/).
-2. Download/Clone this repository and enter into the main directory.
-3. Create a virtual environment: `python -m venv env`
-4. Activate the environment: 
-   
-   In Linux: `source env/bin/activate`
-
-   In Windows: `.\env\Scripts\Activate`
-
-5. Install dependencies (flamapy): `pip install -r requirements.txt`
-     
-    ** In case that you are running Ubuntu and get an error installing flamapy, please install the package python3-dev with the command `sudo apt update && sudo apt install python3-dev` and update wheel and setuptools with the command `pip  install --upgrade pip wheel setuptools` before step 5.
-
-
-## Functionality and usage
-The executable script [test.py](/test.py) serves as an entry point to show the plugin in action.
-
-Simply run: `python test.py` to see it in action over the running feature model presented in the paper.
-
-The following functionality is provided:
-
-
-### Load a feature model in UVL and translate to SMT
-```python
-from flamapy.metamodels.fm_metamodel.transformations import UVLReader
-from flamapy.metamodels.z3_metamodel.transformations import FmToZ3
-
-# Load the feature model from UVL
-fm_model = UVLReader('resources/models/uvl_models/Pizza_z3.uvl').transform()
-# Transform the feature model to SMT
-z3_model = FmToZ3(fm_model).transform()
-```
-
-### Analysis operations
-The following operations are available:
-```python
-from flamapy.metamodels.z3_metamodel.operations import (
-    Z3Satisfiable,
-    Z3Configurations,
-    Z3ConfigurationsNumber,
-    Z3CoreFeatures,
-    Z3DeadFeatures,
-    Z3FalseOptionalFeatures,
-    Z3AttributeOptimization,
-    Z3SatisfiableConfiguration,
-    Z3FeatureBounds,
-    Z3AllFeatureBounds,
-)
-```
-
-- **Satisfiable**
-
-    Return whether the model is satisfiable (valid):
-    ```python
-    satisfiable = Z3Satisfiable().execute(z3_model).get_result()
-    print(f'Satisfiable? (valid?): {satisfiable}')
-    ```
-
-- **Core features**
-
-    Return the core features of the model:
-    ```python
-    core_features = Z3CoreFeatures().execute(z3_model).get_result()
-    print(f'Core features: {core_features}')
-    ```
-
-- **Dead features**
-
-    Return the dead features of the model:
-    ```python
-    dead_features = Z3DeadFeatures().execute(z3_model).get_result()
-    print(f'Dead features: {dead_features}')
-    ```
-
-- **False-Optional features**
-
-    Return the false-optional features of the model:
-    ```python
-    false_optional_features = Z3FalseOptionalFeatures().execute(z3_model).get_result()
-    print(f'False-optional features: {false_optional_features}')
-    ```    
-
-- **Configurations**
-
-    Enumerate the configurations of the model:
-    ```python
-    configurations = Z3Configurations().execute(z3_model).get_result()
-    print(f'Configurations: {len(configurations)}')
-    for i, config in enumerate(configurations, 1):
-        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
-        print(f'Config. {i}: {config_str}')
-    ```
-
-- **Configurations number**
-
-    Return the number of configurations:
-    ```python
-    n_configs = Z3ConfigurationsNumber().execute(z3_model).get_result()
-    print(f'Configurations number: {n_configs}')
-    ```
-
-- **Boundaries analysis of typed features**
-
-    Return the boundaries of the numerical features (Integer, Real, String) of the model:
-    ```python
-    attributes = fm_model.get_attributes()
-    print('Attributes in the model')
-    for attr in attributes:
-        print(f' - {attr.name} ({attr.attribute_type})')
-    
-    variable_bounds = Z3AllFeatureBounds().execute(z3_model).get_result()
-    print('Variable bounds for all typed variables:')
-    for var_name, bounds in variable_bounds.items():
-        print(f' - {var_name}: {bounds}')
-    ```    
-
-- **Configuration optimization based on feature attributes:**
-
-    Return the set of configurations that optimize the given goals (i.e., the pareto front):
-    ```python
-    attribute_optimization_op = Z3AttributeOptimization()
-    attributes = {'Price': OptimizationGoal.MAXIMIZE,
-                  'Kcal': OptimizationGoal.MINIMIZE}
-    attribute_optimization_op.set_attributes(attributes)
-    configurations_with_values = attribute_optimization_op.execute(z3_model).get_result()
-    print(f'Optimum configurations: {len(configurations_with_values)} configs.')
-    for i, config_value in enumerate(configurations_with_values, 1):
-        config, values = config_value
-        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
-        values_str = ', '.join(f'{k}={v}' for k,v in values.items())
-        print(f'Config. {i}: {config_str} | Values: {values_str}')
-    ```    
-
-- Configuration validation:
-
-    Return whether a given partial or full configuration is valid:
-    ```python
-    from flamapy.metamodels.configuration_metamodel.transformations import ConfigurationJSONReader
-    configuration = ConfigurationJSONReader('resources/configs/pizza_z3_config1.json').transform()
-    configuration.set_full(False)
-    print(f'Configuration: {configuration.elements}')
-    satisfiable_configuration_op = Z3SatisfiableConfiguration()
-    satisfiable_configuration_op.set_configuration(configuration)
-    is_satisfiable = satisfiable_configuration_op.execute(z3_model).get_result()
-    print(f'Is the configuration satisfiable? {is_satisfiable}')
-    ```    
-
-**Note:** The Z3Configurations and Z3ConfigurationsNumber operations may takes longer if the number of configuration is huge, or even not finish if the model is unbounded.
-
-**Note:** The Z3Configurations and Z3ConfigurationsNumber operations support also a partial configuration as an additional argument, so the operation will return the result taking into account the given partial configuration. 
-For example:
-
-```python
-from flamapy.core.models import Configuration
-# Create a partial configuration
-elements = {'Pizza': True, 'SpicyLvl': 5}
-partial_config = Configuration(elements)
-# Calculate the number of configuration from the partial configuration
-configs_number_op = Z3ConfigurationsNumber()
-configs_number_op.set_partial_configuration(partial_config)
-n_configs = configs_number_op.execute(z3_model).get_result()
-print(f'#Configurations: {n_configs}')
-```

flamapy_z3-2.5.0.dev0/flamapy/metamodels/z3_metamodel/operations/interfaces/attribute_optimization.py

@@ -1,27 +0,0 @@
-from abc import abstractmethod
-from enum import Enum
-
-from flamapy.core.operations import Operation
-from flamapy.metamodels.configuration_metamodel.models import Configuration
-from flamapy.metamodels.fm_metamodel.models import Attribute
-
-
-class OptimizationGoal(Enum):
-    MAXIMIZE = 'Maximize'
-    MINIMIZE = 'Minimize'
-
-
-class AttributeOptimization(Operation):
-    """This operation returns the configurations that optimize the given attribute(s)."""
-
-    @abstractmethod
-    def __init__(self) -> None:
-        pass
-
-    @abstractmethod
-    def set_attributes(self, attributes: dict[Attribute, OptimizationGoal]) -> None:
-        pass
-
-    @abstractmethod
-    def optimize(self) -> list[Configuration]:
-        pass

flamapy_z3-2.5.0.dev0/flamapy_z3.egg-info/PKG-INFO

@@ -1,202 +0,0 @@
-Metadata-Version: 2.4
-Name: flamapy-z3
-Version: 2.5.0.dev0
-Summary: z3-plugin for the automated analysis of feature models
-Author-email: Flamapy <flamapy@us.es>
-License-Expression: GPL-3.0-or-later
-Project-URL: Homepage, https://github.com/flamapy/z3_metamodel
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: flamapy-fw~=2.5.0.dev0
-Requires-Dist: flamapy-fm~=2.5.0.dev0
-Requires-Dist: z3-solver~=4.14.1.0
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-mock; extra == "dev"
-Requires-Dist: prospector; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: coverage; extra == "dev"
-
-# Automated Analysis of UVL using Satisfiability Modulo Theories
-
-
-## Description
-This repository contains the plugin that supports z3 representations for feature models.
-
-The plugin is based on [flamapy](https://flamapy.github.io/), and relies on the [Z3 solver](https://github.com/Z3Prover/z3?tab=readme-ov-file) library. The architecture is as follows:
-
-<p align="center">
-  <img width="750" src="resources/images/z3metamodel.png">
-</p>
-
-
-## Requirements and Installation
-- [Python 3.11+](https://www.python.org/)
-- [Flamapy](https://www.flamapy.org/)
-
-The framework has been tested in Linux and Windows 11 with Python 3.12. Python 3.13+ may not be still supported.
-
-### Download and installation
-1. Install [Python 3.11+](https://www.python.org/).
-2. Download/Clone this repository and enter into the main directory.
-3. Create a virtual environment: `python -m venv env`
-4. Activate the environment: 
-   
-   In Linux: `source env/bin/activate`
-
-   In Windows: `.\env\Scripts\Activate`
-
-5. Install dependencies (flamapy): `pip install -r requirements.txt`
-     
-    ** In case that you are running Ubuntu and get an error installing flamapy, please install the package python3-dev with the command `sudo apt update && sudo apt install python3-dev` and update wheel and setuptools with the command `pip  install --upgrade pip wheel setuptools` before step 5.
-
-
-## Functionality and usage
-The executable script [test.py](/test.py) serves as an entry point to show the plugin in action.
-
-Simply run: `python test.py` to see it in action over the running feature model presented in the paper.
-
-The following functionality is provided:
-
-
-### Load a feature model in UVL and translate to SMT
-```python
-from flamapy.metamodels.fm_metamodel.transformations import UVLReader
-from flamapy.metamodels.z3_metamodel.transformations import FmToZ3
-
-# Load the feature model from UVL
-fm_model = UVLReader('resources/models/uvl_models/Pizza_z3.uvl').transform()
-# Transform the feature model to SMT
-z3_model = FmToZ3(fm_model).transform()
-```
-
-### Analysis operations
-The following operations are available:
-```python
-from flamapy.metamodels.z3_metamodel.operations import (
-    Z3Satisfiable,
-    Z3Configurations,
-    Z3ConfigurationsNumber,
-    Z3CoreFeatures,
-    Z3DeadFeatures,
-    Z3FalseOptionalFeatures,
-    Z3AttributeOptimization,
-    Z3SatisfiableConfiguration,
-    Z3FeatureBounds,
-    Z3AllFeatureBounds,
-)
-```
-
-- **Satisfiable**
-
-    Return whether the model is satisfiable (valid):
-    ```python
-    satisfiable = Z3Satisfiable().execute(z3_model).get_result()
-    print(f'Satisfiable? (valid?): {satisfiable}')
-    ```
-
-- **Core features**
-
-    Return the core features of the model:
-    ```python
-    core_features = Z3CoreFeatures().execute(z3_model).get_result()
-    print(f'Core features: {core_features}')
-    ```
-
-- **Dead features**
-
-    Return the dead features of the model:
-    ```python
-    dead_features = Z3DeadFeatures().execute(z3_model).get_result()
-    print(f'Dead features: {dead_features}')
-    ```
-
-- **False-Optional features**
-
-    Return the false-optional features of the model:
-    ```python
-    false_optional_features = Z3FalseOptionalFeatures().execute(z3_model).get_result()
-    print(f'False-optional features: {false_optional_features}')
-    ```    
-
-- **Configurations**
-
-    Enumerate the configurations of the model:
-    ```python
-    configurations = Z3Configurations().execute(z3_model).get_result()
-    print(f'Configurations: {len(configurations)}')
-    for i, config in enumerate(configurations, 1):
-        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
-        print(f'Config. {i}: {config_str}')
-    ```
-
-- **Configurations number**
-
-    Return the number of configurations:
-    ```python
-    n_configs = Z3ConfigurationsNumber().execute(z3_model).get_result()
-    print(f'Configurations number: {n_configs}')
-    ```
-
-- **Boundaries analysis of typed features**
-
-    Return the boundaries of the numerical features (Integer, Real, String) of the model:
-    ```python
-    attributes = fm_model.get_attributes()
-    print('Attributes in the model')
-    for attr in attributes:
-        print(f' - {attr.name} ({attr.attribute_type})')
-    
-    variable_bounds = Z3AllFeatureBounds().execute(z3_model).get_result()
-    print('Variable bounds for all typed variables:')
-    for var_name, bounds in variable_bounds.items():
-        print(f' - {var_name}: {bounds}')
-    ```    
-
-- **Configuration optimization based on feature attributes:**
-
-    Return the set of configurations that optimize the given goals (i.e., the pareto front):
-    ```python
-    attribute_optimization_op = Z3AttributeOptimization()
-    attributes = {'Price': OptimizationGoal.MAXIMIZE,
-                  'Kcal': OptimizationGoal.MINIMIZE}
-    attribute_optimization_op.set_attributes(attributes)
-    configurations_with_values = attribute_optimization_op.execute(z3_model).get_result()
-    print(f'Optimum configurations: {len(configurations_with_values)} configs.')
-    for i, config_value in enumerate(configurations_with_values, 1):
-        config, values = config_value
-        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
-        values_str = ', '.join(f'{k}={v}' for k,v in values.items())
-        print(f'Config. {i}: {config_str} | Values: {values_str}')
-    ```    
-
-- Configuration validation:
-
-    Return whether a given partial or full configuration is valid:
-    ```python
-    from flamapy.metamodels.configuration_metamodel.transformations import ConfigurationJSONReader
-    configuration = ConfigurationJSONReader('resources/configs/pizza_z3_config1.json').transform()
-    configuration.set_full(False)
-    print(f'Configuration: {configuration.elements}')
-    satisfiable_configuration_op = Z3SatisfiableConfiguration()
-    satisfiable_configuration_op.set_configuration(configuration)
-    is_satisfiable = satisfiable_configuration_op.execute(z3_model).get_result()
-    print(f'Is the configuration satisfiable? {is_satisfiable}')
-    ```    
-
-**Note:** The Z3Configurations and Z3ConfigurationsNumber operations may takes longer if the number of configuration is huge, or even not finish if the model is unbounded.
-
-**Note:** The Z3Configurations and Z3ConfigurationsNumber operations support also a partial configuration as an additional argument, so the operation will return the result taking into account the given partial configuration. 
-For example:
-
-```python
-from flamapy.core.models import Configuration
-# Create a partial configuration
-elements = {'Pizza': True, 'SpicyLvl': 5}
-partial_config = Configuration(elements)
-# Calculate the number of configuration from the partial configuration
-configs_number_op = Z3ConfigurationsNumber()
-configs_number_op.set_partial_configuration(partial_config)
-n_configs = configs_number_op.execute(z3_model).get_result()
-print(f'#Configurations: {n_configs}')
-```