flamapy-bdd 2.1.0.dev1__tar.gz → 2.1.0.dev2__tar.gz

flamapy_bdd-2.1.0.dev2/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

{flamapy_bdd-2.1.0.dev1 → flamapy_bdd-2.1.0.dev2}/PKG-INFO

@@ -1,18 +1,16 @@
 Metadata-Version: 2.4
 Name: flamapy-bdd
-Version: 2.1.0.dev1
+Version: 2.1.0.dev2
 Summary: bdd-plugin for the automated analysis of feature models
-Home-page: https://github.com/flamapy/bdd_metamodel
-Author: Flamapy
-Author-email: flamapy@us.es
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/bdd_metamodel
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: flamapy-fw~=2.1.0.dev1
 Requires-Dist: flamapy-fm~=2.1.0.dev1
-Requires-Dist: dd~=0.5.7
+Requires-Dist: dd~=0.6.0
 Requires-Dist: graphviz~=0.20
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -20,16 +18,7 @@ Requires-Dist: pytest-mock; extra == "dev"
 Requires-Dist: prospector; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
+Dynamic: license-file
 
 # BDD plugin for flamapy
 - [BDD plugin for flamapy](#bdd-plugin-for-flamapy)

flamapy_bdd-2.1.0.dev2/flamapy/metamodels/bdd_metamodel/models/bdd_model.py

@@ -0,0 +1,172 @@
+import logging
+from enum import Enum
+from typing import Any, Optional
+
+try:
+    from dd.cudd import BDD
+except ImportError:
+    from dd.autoref import BDD
+
+from flamapy.core.models import VariabilityModel
+
+logger = logging.getLogger(__name__)
+
+
+class BDDModel(VariabilityModel):
+    """A Binary Decision Diagram (BDD) representation of the feature model.
+
+    It relies on the dd library: https://pypi.org/project/dd/
+    """
+
+    class LogicConnective(Enum):
+        NOT = "!"
+        OR = "|"
+        AND = "&"
+        IMPLIES = "=>"
+        EQUIVALENCE = "<=>"
+        XOR = "^"
+
+    @staticmethod
+    def get_extension() -> str:
+        return "bdd"
+
+    def __init__(self) -> None:
+        self.bdd: BDD = BDD()  # BDD manager
+        self.root: Any = None
+        self.features_vars: dict[str, str] = {}  # Mapping feature name -> variable name
+        self.vars_features: dict[str, str] = {}  # Mapping variable name -> feature name
+        self.vars_order: list[str] = []  # Ordered list of variables according to the BDD
+
+    def build_bdd(self, expression: str, variables: list[str]) -> None:
+        """Built a BDD from an expression representing a logical formula."""
+        self.bdd.configure(reordering=False)  # Disable dynamic reordering for consistency
+        for var in variables:
+            self.bdd.declare(var)  # Declare variables in the BDD manager
+        self.vars_order = variables  # The order is crucial to detect skipped variables
+        self.root = self.bdd.add_expr(expression)  # Build the logical formula (root node)
+
+    def get_expression(self) -> str:
+        """ Converts the BDD to a readable Boolean expression string."""
+        return self.bdd.to_expr(self.root)
+
+    def get_all_paths(self) -> list[dict[str, bool]]:
+        """Transverses the BDD to find all models (paths to True)."""
+        return list(self.bdd.pick_iter(self.root))
+
+    def count_solutions(self) -> int:
+        """Count the number of valid configurations (SAT)."""
+        return self.bdd.count(self.root, len(self.vars))  # count(node, n_vars)
+
+    def dump_structure(self) -> None:
+        """Prints the structure of the BDD for debugging purposes."""
+        if self.root is None:
+            logger.debug("Empty BDD.")
+            return
+
+        visited = set()
+        # In dd.autoref, bdd.true is the unique terminal.
+        # bdd.false is just ~bdd.true
+
+        def _dump(node: Any, indent: str = "") -> None:
+            if node == self.bdd.true:
+                logger.debug("%s leaf: TRUE", indent)
+                return
+            if node == self.bdd.false:
+                logger.debug("%s leaf: FALSE", indent)
+                return
+
+            # We use the node object for the visited set
+            if node in visited:
+                logger.debug("%s (Ref: %s)", indent, node.var)
+                return
+            visited.add(node)
+
+            logger.debug("%s Node [Var: %s]", indent, node.var)
+            # Safe access: only internal nodes have children
+            _dump(node.low, indent + "  Low: ")
+            _dump(node.high, indent + " High: ")
+
+        logger.debug("Exploring BDD (Root: %s)", self.root)
+        _dump(self.root)
+
+    def save_bdd(self,
+                 path: str,
+                 roots: Optional[Any] = None,
+                 filetype: Optional[str] = None) -> None:
+        if filetype is None:
+            filetype = self.bdd.dump(filename=path, roots=roots)
+        else:
+            self.bdd.dump(filename=path, roots=roots, filetype=filetype)
+
+    @staticmethod
+    def load_bdd(path: str, vars: Optional[list[str]] = None) -> 'BDDModel':
+        bdd_model = BDDModel()
+        if vars is not None:
+            for var in vars:
+                bdd_model.bdd.declare(var)
+        roots = bdd_model.bdd.load(path)
+        if isinstance(roots, dict):
+            bdd_model.root = next(iter(roots.values()))
+        elif isinstance(roots, list):
+            bdd_model.root = roots[0]
+        else:
+            bdd_model.root = roots
+        all_vars = list(bdd_model.bdd.vars)
+        sorted_vars = sorted(all_vars, key=bdd_model.bdd.level_of_var)
+        bdd_model.vars_order = sorted_vars
+        bdd_model.vars_features = {var: var for var in bdd_model.vars_order}
+        bdd_model.features_vars = {var: var for var in bdd_model.vars_order}
+        return bdd_model
+
+    def __str__(self) -> str:
+        bdd = self.bdd
+        root = self.root
+        # Recolect reachable nodes from the root
+        # This avoids counting orphan nodes that are in the manager's memory
+        reachable_nodes = set()
+        to_visit = [root]
+        while to_visit:
+            u = to_visit.pop()
+            if u not in reachable_nodes:
+                reachable_nodes.add(u)
+                if u.var is not None:
+                    to_visit.extend([u.low, u.high])
+
+        result = ""
+        result += f"Total nodes in manager: {len(self.bdd)}\n"
+        result += f"Nodes in this formula: {len(reachable_nodes)}\n"
+
+        root_var = root.var if root.var is not None else "Terminal"
+        result += f"Root node: {root} (Variable: {root_var}, Negated: {root.negated})\n"
+
+        # Group nodes by level
+        # In dd, level 0 is the top (root) and goes down
+        nodes_by_level: dict[int, list[Any]] = {}
+        terminals: list[Any] = []
+        for node in reachable_nodes:
+            if node.var is not None:
+                # Get the level of the variable
+                level = bdd.level_of_var(node.var)
+                if level not in nodes_by_level:
+                    nodes_by_level[level] = []
+                nodes_by_level[level].append(node)
+            else:
+                terminals.append(node)
+
+        # Print levels in order
+        for level in sorted(nodes_by_level.keys()):
+            var_name = self.vars_order[level]
+            num_nodes = len(nodes_by_level[level])
+            result += f"Level {level:2} | Variable: {var_name:15} | Nodes: {num_nodes}"
+            # Optional: print IDs of nodes at this level
+            node_ids = [str(n) for n in nodes_by_level[level]]
+            result += f"   IDs: {', '.join(node_ids)}\n"
+
+        # Terminal nodes
+        # IIn dd (CUDD), there is only one real terminal node (True)
+        # The value False is represented as a negated edge to True
+        for t in terminals:
+            val = "TRUE" if not t.negated else "FALSE"
+            result += f"Terminal Node ID: {t} (Semantic Value: {val})\n"
+        #result += f"Expression: {self.get_expression()}\n"
+        return result

flamapy_bdd-2.1.0.dev2/flamapy/metamodels/bdd_metamodel/models/utils/__init__.py

@@ -0,0 +1,5 @@
+from .txtcnf import CNFLogicConnective, TextCNFNotation, TextCNFModel
+from .pl_model import PLModel
+
+
+__all__ = ["CNFLogicConnective", "PLModel", "TextCNFModel", "TextCNFNotation"]

flamapy_bdd-2.1.0.dev2/flamapy/metamodels/bdd_metamodel/models/utils/pl_model.py

@@ -0,0 +1,178 @@
+import re
+import itertools
+
+from flamapy.core.models.ast import ASTOperation
+from flamapy.metamodels.fm_metamodel.models import FeatureModel, Relation, Constraint
+
+
+class PLModel():
+    """A model representing a Prepositional Logical Formula (PL)."""
+
+    LOGIC_CONNECTIVES = {
+        "NOT": "!",
+        "OR": "|",
+        "AND": "&",
+        "IMPLIES": "=>",
+        "EQUIVALENCE": "<=>",
+        "XOR": "^"}
+
+    def __init__(self, logic_connectives: dict[str, str] = LOGIC_CONNECTIVES) -> None:
+        self.formula: str = ""
+        self.variables: set[str] = set()
+        self.logic_connectives: dict[str, str] = logic_connectives
+
+    def build_from_feature_model(self, fm_model: FeatureModel) -> str:
+        """Builds a PL formula from a feature model."""
+        self.variables = {feature.name for feature in fm_model.get_features()}
+        self.formula = self._traverse_feature_tree(fm_model)
+        return self.formula
+
+    def _traverse_feature_tree(self, feature_model: FeatureModel) -> str:
+        """Traverse the feature tree from the root and return the propositional formula."""
+        if feature_model is None or feature_model.root is None:
+            return ""
+        # The root is always present
+        root_feature = feature_model.root
+        formula = [root_feature.name]
+        for feature in feature_model.get_features():
+            for relation in feature.get_relations():
+                formula.append(self._get_relation_formula(relation))
+        for constraint in feature_model.get_logical_constraints():
+            formula.append(self._get_constraint_formula(constraint))
+        propositional_formula = f" {self.logic_connectives['AND']} ".join(f"({f})" for f in formula)
+        return propositional_formula
+
+    def _get_relation_formula(self, relation: Relation) -> str:
+        result = ""
+        if relation.is_mandatory():
+            result = self._get_mandatory_formula(relation)
+        elif relation.is_optional():
+            result = self._get_optional_formula(relation)
+        elif relation.is_or():
+            result = self._get_or_formula(relation)
+        elif relation.is_alternative():
+            result = self._get_alternative_formula(relation)
+        elif relation.is_mutex():
+            result = self._get_mutex_formula(relation)
+        elif relation.is_cardinal():
+            result = self._get_cardinality_formula(relation)
+        return result
+
+    def _get_mandatory_formula(self, relation: Relation) -> str:
+        parent = relation.parent.name
+        child = relation.children[0].name
+        return f"{parent} {self.logic_connectives['EQUIVALENCE']} {child}"
+
+    def _get_optional_formula(self, relation: Relation) -> str:
+        parent = relation.parent.name
+        child = relation.children[0].name
+        return f"{child} {self.logic_connectives['IMPLIES']} {parent}"
+
+    def _get_or_formula(self, relation: Relation) -> str:
+        parent = relation.parent.name
+        children = f" {self.logic_connectives['OR']} ".join(
+            child.name for child in relation.children
+        )
+        return f"{parent} {self.logic_connectives['EQUIVALENCE']} ({children})"
+
+    def _get_alternative_formula(self, relation: Relation) -> str:
+        formula = []
+        parent = relation.parent.name
+        children = {child.name for child in relation.children}
+        equiv_str = self.logic_connectives['EQUIVALENCE']
+        and_str = self.logic_connectives['AND']
+        not_str = self.logic_connectives['NOT']
+        for child in children:
+            children_negatives = children - {child}
+            neg_children = f" {and_str} ".join(not_str + ch for ch in children_negatives)
+            formula.append(f"{child} {equiv_str} ({neg_children} {and_str} {parent})")
+        return f" {and_str} ".join(f"({f})" for f in formula)
+
+    def _get_mutex_formula(self, relation: Relation) -> str:
+        formula = []
+        parent = relation.parent.name
+        children = {child.name for child in relation.children}
+        equiv_str = self.logic_connectives['EQUIVALENCE']
+        and_str = self.logic_connectives['AND']
+        not_str = self.logic_connectives['NOT']
+        or_str = self.logic_connectives['OR']
+        for child in children:
+            children_negatives = children - {child}
+            neg_children = f" {and_str} ".join(not_str + cn for cn in children_negatives)
+            formula.append(f"{child} {equiv_str} ({neg_children} {and_str} {parent})")
+        formula_str = f" {and_str} ".join(f"({f})" for f in formula)
+        children_or = f" {or_str} ".join(child for child in children)
+        left = f"({parent} {equiv_str} {not_str} ({children_or}))"
+        return f"{left} {or_str} ({formula_str})"
+
+    def _get_cardinality_formula(self, relation: Relation) -> str:
+        parent = relation.parent.name
+        children = [child.name for child in relation.children]
+        not_str = self.logic_connectives['NOT']
+        and_str = self.logic_connectives['AND']
+        or_str = self.logic_connectives['OR']
+
+        all_clauses = []
+
+        # 1. If the parent is active, prohibit combinations outside the range [min..max]
+        for val in range(len(children) + 1):
+            if val < relation.card_min or val > relation.card_max:
+                for combination in itertools.combinations(children, val):
+                    # To prohibit an exact combination: (NOT parent OR NOT child1 OR child2...)
+                    clause_parts = [f"{not_str}{parent}"]
+                    for child in children:
+                        if child in combination:
+                            clause_parts.append(f"{not_str}{child}")
+                        else:
+                            clause_parts.append(child)
+                    all_clauses.append(f"({f' {or_str} '.join(clause_parts)})")
+
+        # 2. If the parent is inactive, NO child can be active (or combinations not allowed)
+        # Following the logic of the first script to maintain consistency:
+        for val in range(1, len(children) + 1):
+            for combination in itertools.combinations(children, val):
+                clause_parts = [parent]
+                for child in children:
+                    if child in combination:
+                        clause_parts.append(f"{not_str}{child}")
+                    else:
+                        clause_parts.append(child)
+                all_clauses.append(f"({f' {or_str} '.join(clause_parts)})")
+
+        return f" {and_str} ".join(all_clauses)
+
+    def _get_constraint_formula(self, ctc: Constraint) -> str:
+        constraint_str = ctc.ast.pretty_str()
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.XOR.value}\b", self.logic_connectives['XOR'], constraint_str
+        )
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.NOT.value}\b", self.logic_connectives['NOT'], constraint_str
+        )
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.AND.value}\b", self.logic_connectives['AND'], constraint_str
+        )
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.OR.value}\b", self.logic_connectives['OR'], constraint_str
+        )
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.IMPLIES.value}\b",
+            self.logic_connectives['IMPLIES'],
+            constraint_str,
+        )
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.EQUIVALENCE.value}\b",
+            self.logic_connectives['EQUIVALENCE'],
+            constraint_str,
+        )
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.REQUIRES.value}\b",
+            self.logic_connectives['IMPLIES'],
+            constraint_str,
+        )
+        constraint_str = re.sub(
+            rf"\b{ASTOperation.EXCLUDES.value}\b",
+            f"{self.logic_connectives['IMPLIES']} {self.logic_connectives['NOT']}",
+            constraint_str,
+        )
+        return constraint_str

{flamapy_bdd-2.1.0.dev1 → flamapy_bdd-2.1.0.dev2}/flamapy/metamodels/bdd_metamodel/operations/__init__.py

@@ -14,14 +14,18 @@ from .bdd_commonality_factor import BDDCommonalityFactor
 from .bdd_homogeneity import BDDHomogeneity
 from .bdd_metrics import BDDMetrics
 from .bdd_satisfiable_configuration import BDDSatisfiableConfiguration
+from .bdd_false_optional_features import BDDFalseOptionalFeatures
+from .bdd_configurations_with_n_features import BDDConfigurationsWithNFeatures
 
 
 __all__ = [
     "BDDCommonalityFactor",
     "BDDConfigurations",
     "BDDConfigurationsNumber",
+    "BDDConfigurationsWithNFeatures",
     "BDDCoreFeatures",
     "BDDDeadFeatures",
+    "BDDFalseOptionalFeatures",
     "BDDFeatureInclusionProbability",
     "BDDHomogeneity",
     "BDDMetrics",
@@ -32,5 +36,5 @@ __all__ = [
     "BDDSatisfiableConfiguration",
     "BDDUniqueFeatures",
     "BDDVariability",
-    "BDDVariantFeatures",
+    "BDDVariantFeatures"
 ]

{flamapy_bdd-2.1.0.dev1 → flamapy_bdd-2.1.0.dev2}/flamapy/metamodels/bdd_metamodel/operations/bdd_configurations.py

@@ -36,22 +36,21 @@ def configurations(
 ) -> list[Configuration]:
     if partial_config is None:
         u_func = bdd_model.root
-        care_vars = set(bdd_model.variables_features)
+        care_vars = set(bdd_model.vars_order)
         elements = {}
     else:
-        values = {bdd_model.mapping_secure_names[f]: selected
+        values = {bdd_model.features_vars[f]: selected
                   for f, selected in partial_config.elements.items()}
         u_func = bdd_model.bdd.let(values, bdd_model.root)
-        care_vars = set(bdd_model.variables_features) - set(values.keys())
-        elements = {bdd_model.mapping_secure_names[f]: selected
-                    for f, selected in partial_config.elements.items()}
+        care_vars = set(bdd_model.vars_order) - set(values.keys())
+        elements = partial_config.elements.items()
 
     configs = []
     for assignment in bdd_model.bdd.pick_iter(u_func, care_vars=care_vars):
         features = {
-            bdd_model.variables_features[f]: True for f in assignment.keys() if assignment[f]
+            bdd_model.vars_features[f]: True for f in assignment.keys() if assignment[f]
         }
+
         features = features | elements
-        new_features = {bdd_model.mapping_secure_names_inverted[f]: v for f, v in features.items()}
-        configs.append(Configuration(new_features))
+        configs.append(Configuration(features))
     return configs

{flamapy_bdd-2.1.0.dev1 → flamapy_bdd-2.1.0.dev2}/flamapy/metamodels/bdd_metamodel/operations/bdd_configurations_number.py

@@ -36,12 +36,16 @@ def configurations_number(
 ) -> int:
     if partial_configuration is None:
         u_func = bdd_model.root
-        n_vars = len(bdd_model.variables_features)
+        n_vars = len(bdd_model.vars_order)
     else:
         values = {
-            bdd_model.features_variables[bdd_model.mapping_secure_names[f]]: selected
+            bdd_model.features_vars[f]: selected
             for f, selected in partial_configuration.elements.items()
         }
+        if partial_configuration.is_full:
+            for feature, variable in bdd_model.features_vars.items():
+                if feature not in partial_configuration.elements:
+                    values[variable] = False
         u_func = bdd_model.bdd.let(values, bdd_model.root)
-        n_vars = len(bdd_model.variables_features) - len(values)
+        n_vars = len(bdd_model.vars_order) - len(values)
     return int(bdd_model.bdd.count(u_func, nvars=n_vars))