flamapy-bdd 1.0.1.dev0__tar.gz → 2.0.0.dev1__tar.gz

{flamapy-bdd-1.0.1.dev0 → flamapy-bdd-2.0.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flamapy-bdd
-Version: 1.0.1.dev0
+Version: 2.0.0.dev1
 Summary: bdd-plugin for the automated analysis of feature models
 Home-page: https://github.com/flamapy/bdd_metamodel
 Author: Flamapy
@@ -19,8 +19,9 @@ Provides-Extra: dev
   - [Description](#description)
   - [Requirements and Installation](#requirements-and-installation)
   - [Functionality and usage](#functionality-and-usage)
-    - [Load a feature model and create the BDD](#load-a-feature-model-and-create-the-bdd)
+    - [Load a feature model in UVL and create the BDD](#load-a-feature-model-in-uvl-and-create-the-bdd)
     - [Save the BDD in a file](#save-the-bdd-in-a-file)
+    - [Load the BDD from a file](#load-the-bdd-from-a-file)
     - [Analysis operations](#analysis-operations)
   - [Contributing to the BDD plugin](#contributing-to-the-bdd-plugin)
 
@@ -64,13 +65,13 @@ The executable script [test_bdd_metamodel.py](https://github.com/flamapy/bdd_met
 The following functionality is provided:
 
 
-### Load a feature model and create the BDD
+### Load a feature model in UVL and create the BDD
 ```python
-from flamapy.metamodels.fm_metamodel.transformations.featureide_reader import FeatureIDEReader
-from flamapy.metamodels.bdd_metamodel.transformations.fm_to_bdd import FmToBDD
+from flamapy.metamodels.fm_metamodel.transformations import UVLReader
+from flamapy.metamodels.bdd_metamodel.transformations import FmToBDD
 
-# Load the feature model from FeatureIDE
-feature_model = FeatureIDEReader('input_fms/featureide_models/pizzas.xml').transform()
+# Load the feature model from UVL
+feature_model = UVLReader('models/uvl_models/pizzas.uvl').transform()
 # Create the BDD from the feature model
 bdd_model = FmToBDD(feature_model).transform()
 ```
@@ -78,114 +79,116 @@ bdd_model = FmToBDD(feature_model).transform()
 
 ### Save the BDD in a file
 ```python
-from flamapy.metamodels.bdd_metamodel.transformations.bdd_writer import BDDWriter, BDDDumpFormat
+from flamapy.metamodels.bdd_metamodel.transformations import PNGWriter, DDDMPv3Writer
 # Save the BDD as an image in PNG
-BDDWriter(path='my_bdd.png',
-          source_model=bdd_model,
-          roots=[bdd_model.root],
-          output_format=BDDDumpFormat.PNG).transform()
+PNGWriter(path='my_bdd.png', bdd_model).transform()
+# Save the BDD in a .dddmp file
+DDDMPv3Writer(f'my_bdd.dddmp', bdd_model).transform()
 ```
-Formats supported: DDDMP_V3 ('dddmp'), DDDMP_V2 ('dddmp2'), PDF ('pdf'), PNG ('png'), SVG ('svg').
+Writers available: DDDMPv3 ('dddmp'), DDDMPv2 ('dddmp'), JSON ('json'), Pickle ('p'), PDF ('pdf'), PNG ('png'), SVG ('svg').
 
+### Load the BDD from a file
+```python
+from flamapy.metamodels.bdd_metamodel.transformations import JSONReader
+# Load the BDD from a .json file
+bdd_model = JSONReader(path='path/to/my_bdd.json').transform()
+```
+Readers available: JSON ('json'), DDDMP ('dddmp'), Pickle ('p').
+
+*NOTE:* DDDMP and Pickle readers are not fully supported yet.
 
 ### Analysis operations
 
-- Products number
+- Satisfiable
 
-    Return the number of products (configurations):
+    Return whether the model is satisfiable (valid):
     ```python
-    from flamapy.metamodels.bdd_metamodel.operations import BDDProductsNumber
-    nof_products = BDDProductsNumber().execute(bdd_model).get_result()
-    print(f'#Products: {nof_products}')
-    ```
-    or alternatively:
-    ```python
-    from flamapy.metamodels.bdd_metamodel.operations import products_number
-    nof_products = products_number(bdd_model)
-    print(f'#Products: {nof_products}')
+    from flamapy.metamodels.bdd_metamodel.operations import BDDSatisfiable
+    satisfiable = BDDSatisfiable().execute(bdd_model).get_result()
+    print(f'Satisfiable? (valid?): {satisfiable}')
     ```
 
-- Products
+- Configurations number
 
-    Return the list of products (configurations):
+    Return the number of configurations:
     ```python
-    from flamapy.metamodels.bdd_metamodel.operations import BDDProducts
-    list_products = BDDProducts().execute(bdd_model).get_result()
-    for i, prod in enumerate(list_products):
-        print(f'Product {i}: {[feat for feat in prod.elements if prod.elements[feat]]}')
+    from flamapy.metamodels.bdd_metamodel.operations import BDDConfigurationsNumber
+    n_configs = BDDConfigurationsNumber().execute(bdd_model).get_result()
+    print(f'#Configurations: {n_configs}')
     ```
-    or alternatively:
+
+- Configurations
+
+    Enumerate the configurations of the model:
     ```python
-    from flamapy.metamodels.bdd_metamodel.operations import products
-    nof_products = products(bdd_model)
-    for i, prod in enumerate(list_products):
-        print(f'Product {i}: {[feat for feat in prod.elements if prod.elements[feat]]}')
+    from flamapy.metamodels.bdd_metamodel.operations import BDDConfigurations
+    configurations = BDDConfigurations().execute(bdd_model).get_result()
+    for i, config in enumerate(configurations, 1):
+        print(f'Config {i}: {[feat for feat in config.elements if config.elements[feat]]}')
     ```
 
 - Sampling
 
-    Return a sample of the given size of uniform random products (configurations) with or without replacement:
+    Return a sample of the given size of uniform random configurations with or without replacement:
     ```python
     from flamapy.metamodels.bdd_metamodel.operations import BDDSampling
-    list_sample = BDDSampling(size=5, with_replacement=False).execute(bdd_model).get_result()
-    for i, prod in enumerate(list_sample):
-        print(f'Product {i}: {[feat for feat in prod.elements if prod.elements[feat]]}')
-    ```
-    or alternatively:
-    ```python
-    from flamapy.metamodels.bdd_metamodel.operations import sample
-    list_sample = sample(bdd_model, size=5, with_replacement=False)
-    for i, prod in enumerate(list_sample):
-        print(f'Product {i}: {[feat for feat in prod.elements if prod.elements[feat]]}')
+    sampling_op = BDDSampling()
+    sampling_op.set_sample_size(5)
+    sampling_op.set_with_replacement(False)  # Default False
+    sample = sampling_op.execute(bdd_model).get_result()
+    for i, config in enumerate(sample, 1):
+        print(f'Config {i}: {[feat for feat in config.elements if config.elements[feat]]}')
     ```
 
 - Product Distribution
 
-    Return the number of products having a given number of features:
-    ```python
-    from flamapy.metamodels.bdd_metamodel.operations import BDDProductDistributionBF
-    dist = BDDProductDistributionBF().execute(bdd_model).get_result()
-    print(f'Product Distribution: {dist}')
-    ```
-    or alternatively:
+    Return the number of products (configurations) having a given number of features:
     ```python
-    from flamapy.metamodels.bdd_metamodel.operations import product_distribution
-    dist = product_distribution(bdd_model)
+    from flamapy.metamodels.bdd_metamodel.operations import BDDProductDistribution
+    dist = BDDProductDistribution().execute(bdd_model).get_result()
     print(f'Product Distribution: {dist}')
     ```
 
 - Feature Inclusion Probability
 
-    Return the probability for a feature to be included in a valid product:
+    Return the probability for a feature to be included in a valid configuration:
     ```python
-    from flamapy.metamodels.bdd_metamodel.operations import BDDFeatureInclusionProbabilityBF
-    prob = BDDFeatureInclusionProbabilityBF().execute(bdd_model).get_result()
+    from flamapy.metamodels.bdd_metamodel.operations import BDDFeatureInclusionProbability
+    prob = BDDFeatureInclusionProbability().execute(bdd_model).get_result()
     for feat in prob.keys():
         print(f'{feat}: {prob[feat]}')
     ```
-    or alternatively:
+
+- Core features
+
+    Return the core features (those features that are present in all the configurations):
     ```python
-    from flamapy.metamodels.bdd_metamodel.operations import feature_inclusion_probability
-    prob = feature_inclusion_probability(bdd_model)
-    for feat in prob.keys():
-        print(f'{feat}: {prob[feat]}')
+    from flamapy.metamodels.bdd_metamodel.operations import BDDCoreFeatures
+    core_features = BDDCoreFeatures().execute(bdd_model).get_result()
+    print(f'Core features: {core_features}')
     ```
 
-All analysis 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:
+- Dead features
+
+    Return the dead features (those features that are not present in any configuration):
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDDeadFeatures
+    dead_features = BDDDeadFeatures().execute(bdd_model).get_result()
+    print(f'Dead features: {dead_features}')
+    ```
+
+Most analysis 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, 'Big': True}
 partial_config = Configuration(elements)
-# Calculate the number of products from the partial configuration
-nof_products = BDDProductsNumber(partial_config).execute(bdd_model).get_result()
-print(f'#Products: {nof_products}')
-```
-or alternatively:
-```python
-nof_products = products(bdd_model, partial_config)
-print(f'#Products: {nof_products}')
+# Calculate the number of configuration from the partial configuration
+configs_number_op = BDDConfigurationsNumber()
+configs_number_op.set_partial_configuration(partial_config)
+n_configs = configs_number_op.execute(bdd_model).get_result()
+print(f'#Configurations: {n_configs}')
 ```
 
 

flamapy-bdd-2.0.0.dev1/README.md

@@ -0,0 +1,198 @@
+# BDD plugin for flamapy
+- [BDD plugin for flamapy](#bdd-plugin-for-flamapy)
+  - [Description](#description)
+  - [Requirements and Installation](#requirements-and-installation)
+  - [Functionality and usage](#functionality-and-usage)
+    - [Load a feature model in UVL and create the BDD](#load-a-feature-model-in-uvl-and-create-the-bdd)
+    - [Save the BDD in a file](#save-the-bdd-in-a-file)
+    - [Load the BDD from a file](#load-the-bdd-from-a-file)
+    - [Analysis operations](#analysis-operations)
+  - [Contributing to the BDD plugin](#contributing-to-the-bdd-plugin)
+
+
+## Description
+This plugin supports Binary Decision Diagrams (BDDs) representations for feature models.
+
+The plugin is based on [flamapy](https://github.com/flamapy/core) and thus, it follows the same architecture:
+
+<p align="center">
+  <img width="750" src="doc/bdd_plugin.png">
+</p>
+
+The BDD plugin relies on the [dd](https://github.com/tulip-control/dd) library to manipulate BDDs.
+The complete documentation of such library is available [here](https://github.com/tulip-control/dd/blob/main/doc.md).
+
+The following is an example of feature model and its BDD using complemented arcs.
+
+<p align="center">
+  <img width="750" src="doc/fm_example.png">
+</p>
+
+<p align="center">
+  <img width="750" src="doc/bdd_example.svg">
+</p>
+
+## Requirements and Installation
+- Python 3.9+
+- This plugin depends on the [flamapy core](https://github.com/flamapy/core) and on the [Feature Model plugin](https://github.com/flamapy/fm_metamodel).
+
+```
+pip install flamapy flamapy-fm flamapy-bdd
+```
+
+We have tested the plugin on Linux, but Windows is also supported.
+
+
+## Functionality and usage
+The executable script [test_bdd_metamodel.py](https://github.com/flamapy/bdd_metamodel/blob/master/tests/test_bdd_metamodel.py) serves as an entry point to show the plugin in action.
+
+The following functionality is provided:
+
+
+### Load a feature model in UVL and create the BDD
+```python
+from flamapy.metamodels.fm_metamodel.transformations import UVLReader
+from flamapy.metamodels.bdd_metamodel.transformations import FmToBDD
+
+# Load the feature model from UVL
+feature_model = UVLReader('models/uvl_models/pizzas.uvl').transform()
+# Create the BDD from the feature model
+bdd_model = FmToBDD(feature_model).transform()
+```
+
+
+### Save the BDD in a file
+```python
+from flamapy.metamodels.bdd_metamodel.transformations import PNGWriter, DDDMPv3Writer
+# Save the BDD as an image in PNG
+PNGWriter(path='my_bdd.png', bdd_model).transform()
+# Save the BDD in a .dddmp file
+DDDMPv3Writer(f'my_bdd.dddmp', bdd_model).transform()
+```
+Writers available: DDDMPv3 ('dddmp'), DDDMPv2 ('dddmp'), JSON ('json'), Pickle ('p'), PDF ('pdf'), PNG ('png'), SVG ('svg').
+
+### Load the BDD from a file
+```python
+from flamapy.metamodels.bdd_metamodel.transformations import JSONReader
+# Load the BDD from a .json file
+bdd_model = JSONReader(path='path/to/my_bdd.json').transform()
+```
+Readers available: JSON ('json'), DDDMP ('dddmp'), Pickle ('p').
+
+*NOTE:* DDDMP and Pickle readers are not fully supported yet.
+
+### Analysis operations
+
+- Satisfiable
+
+    Return whether the model is satisfiable (valid):
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDSatisfiable
+    satisfiable = BDDSatisfiable().execute(bdd_model).get_result()
+    print(f'Satisfiable? (valid?): {satisfiable}')
+    ```
+
+- Configurations number
+
+    Return the number of configurations:
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDConfigurationsNumber
+    n_configs = BDDConfigurationsNumber().execute(bdd_model).get_result()
+    print(f'#Configurations: {n_configs}')
+    ```
+
+- Configurations
+
+    Enumerate the configurations of the model:
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDConfigurations
+    configurations = BDDConfigurations().execute(bdd_model).get_result()
+    for i, config in enumerate(configurations, 1):
+        print(f'Config {i}: {[feat for feat in config.elements if config.elements[feat]]}')
+    ```
+
+- Sampling
+
+    Return a sample of the given size of uniform random configurations with or without replacement:
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDSampling
+    sampling_op = BDDSampling()
+    sampling_op.set_sample_size(5)
+    sampling_op.set_with_replacement(False)  # Default False
+    sample = sampling_op.execute(bdd_model).get_result()
+    for i, config in enumerate(sample, 1):
+        print(f'Config {i}: {[feat for feat in config.elements if config.elements[feat]]}')
+    ```
+
+- Product Distribution
+
+    Return the number of products (configurations) having a given number of features:
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDProductDistribution
+    dist = BDDProductDistribution().execute(bdd_model).get_result()
+    print(f'Product Distribution: {dist}')
+    ```
+
+- Feature Inclusion Probability
+
+    Return the probability for a feature to be included in a valid configuration:
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDFeatureInclusionProbability
+    prob = BDDFeatureInclusionProbability().execute(bdd_model).get_result()
+    for feat in prob.keys():
+        print(f'{feat}: {prob[feat]}')
+    ```
+
+- Core features
+
+    Return the core features (those features that are present in all the configurations):
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDCoreFeatures
+    core_features = BDDCoreFeatures().execute(bdd_model).get_result()
+    print(f'Core features: {core_features}')
+    ```
+
+- Dead features
+
+    Return the dead features (those features that are not present in any configuration):
+    ```python
+    from flamapy.metamodels.bdd_metamodel.operations import BDDDeadFeatures
+    dead_features = BDDDeadFeatures().execute(bdd_model).get_result()
+    print(f'Dead features: {dead_features}')
+    ```
+
+Most analysis 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, 'Big': True}
+partial_config = Configuration(elements)
+# Calculate the number of configuration from the partial configuration
+configs_number_op = BDDConfigurationsNumber()
+configs_number_op.set_partial_configuration(partial_config)
+n_configs = configs_number_op.execute(bdd_model).get_result()
+print(f'#Configurations: {n_configs}')
+```
+
+
+## Contributing to the BDD plugin
+To contribute in the development of this plugin:
+
+1. Fork the repository into your GitHub account.
+2. Clone the repository: `git@github.com:<<username>>/bdd_metamodel.git`
+3. Create a virtual environment: `python -m venv env`
+4. Activate the virtual environment: `source env/bin/activate`
+5. Install the plugin dependencies: `pip install flamapy flamapy-fm`
+6. Install the BDD plugin from the source code: `pip install -e bdd_metamodel`
+
+Please try to follow the standards code quality to contribute to this plugin before creating a Pull Request:
+
+- To analyze your Python code and output information about errors, potential problems, convention violations and complexity, pass the prospector with:
+
+    `make lint`
+
+- To analyze the static type checker for Python and find bugs, pass the Mypy:
+
+    `make mypy`
+

flamapy-bdd-2.0.0.dev1/flamapy/metamodels/bdd_metamodel/models/__init__.py

@@ -0,0 +1,4 @@
+from .bdd_model import BDDModel
+
+
+__all__ = ['BDDModel']

flamapy-bdd-2.0.0.dev1/flamapy/metamodels/bdd_metamodel/models/bdd_model.py

@@ -0,0 +1,200 @@
+from enum import Enum
+from typing import Optional, Any
+
+# Low-level interface to pure Python implementation (wrapped by dd.autoref.BDD).
+import dd.bdd as _dd_bdd
+# Import the best available interface:
+try:
+    import dd.cudd as _bdd  # High-level interface to a C implementation.
+except ImportError:
+    import dd.autoref as _bdd  # High-level interface to pure Python implementation.
+
+
+from flamapy.core.models import VariabilityModel
+
+
+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.BDD()  # BDD manager
+        self._root: Optional[_bdd.Function | int] = None
+        self._variables: list[Any] = []
+        self._levels_variables: dict[int, Any] = {}
+
+    @property
+    def bdd(self) -> _bdd.BDD | _dd_bdd.BDD:
+        return self._bdd
+
+    @bdd.setter
+    def bdd(self, new_bdd: _bdd.BDD | _dd_bdd.BDD) -> None:
+        self._bdd = new_bdd
+        self._variables = list(self._bdd.vars)
+        self._root = next(iter(self._bdd.roots), None)
+        self._levels_variables = {l: v for v, l in self._bdd.var_levels.items()}
+
+    @property
+    def root(self) -> _bdd.Function | int:
+        return self._root
+
+    @root.setter
+    def root(self, new_root: _bdd.Function | int) -> None:
+        self._root = new_root
+        self._variables = list(self._bdd.vars)
+        self._levels_variables = {l: v for v, l in self._bdd.var_levels.items()}
+
+    @property
+    def variables(self) -> list[Any]:
+        return self._variables
+
+    @classmethod
+    def from_logic_formula(cls, formula: str, variables: list[Any]) -> 'BDDModel':
+        """Build the BDD from a logic formula, and the list of variables.
+
+        The logic formula can be a CNF formula or a propositional logic formula.
+        """
+        bdd_model = cls()
+        # Store variables
+        bdd_model._variables = variables
+        # Declare variables
+        bdd_model._bdd.declare(*variables)
+        # Build the BDD
+        bdd_model._root = bdd_model._bdd.add_expr(formula)
+
+        # Reorder for optimization
+        # Warning! Reordering may make the root starting to level > 0, and thus,
+        # operations won't work correctly.
+        # bdd_model._bdd.reorder()  
+
+        # Levels and variables (dict for optimization)
+        bdd_model._levels_variables = {l: v for v, l in bdd_model._bdd.var_levels.items()}
+        return bdd_model
+
+    def level_of_var(self, var: Any) -> Optional[int]:
+        """Return the level of a given variable."""
+        return self._bdd.var_levels.get(var, None)
+
+    def var_at_level(self, level: int) -> Optional[Any]:
+        """Return the variable at the given level."""
+        return self._levels_variables.get(level, None)
+
+    def var(self, node: _bdd.Function | int) -> Optional[Any]:
+        """Return the variable of the node.
+
+        It returns None if the node is a terminal node.
+        """
+        if self.is_terminal_node(node):
+            return None
+        if isinstance(node, int):
+            level, _, _ = self._bdd.succ(node)
+            return self.var_at_level(level)
+        return node.var
+
+    def level(self, node: _bdd.Function | int) -> Optional[int]:
+        """Return the level of the node.
+
+        Non-terminal nodes start at 0.
+        Terminal nodes have level `s' being the `s' the number of variables.
+        """
+        #level, _, _ = self._bdd.succ(node)
+        return self.level_of_var(self.var(node))
+
+    def nof_nodes(self) -> int:
+        """Return number of nodes in the BDD."""
+        return len(self._bdd)
+
+    def get_node(self, var: Any) -> _bdd.Function | int:
+        """Return the node of the variable."""
+        return self._bdd.var(var)
+
+    def index(self, node: _bdd.Function | int) -> Optional[int]:
+        """Position (index) of the variable that labels the node `n` in the ordering.
+
+        Indexes start at 1.
+        Terminal nodes (n0 and n1) have indexes `s + 1`, being `s' the number of variables.
+        Note that index(n) = level(n) + 1.
+
+        Example: node `n4` is labeled `B`, and `B` is in the 2nd position in ordering `[A,B,C]`,
+        thus level(n4) = 2.
+        """
+        if self.is_terminal_node(node):
+            return len(self.variables) + 1
+        level = self.level(node)
+        return level + 1 if level is not None else None
+
+    def negated(self, node: _bdd.Function | int) -> bool:
+        """Return whether the node is negated."""
+        if isinstance(node, int):
+            return node < 0
+        return node.negated
+
+    def get_terminal_node_n0(self) -> _bdd.Function | int:
+        return self._bdd.false
+
+    def get_terminal_node_n1(self) -> _bdd.Function | int:
+        return self._bdd.true
+
+    def is_terminal_node(self, node: _bdd.Function | int) -> bool:
+        """Check if the node is a terminal node."""
+        return self.is_terminal_n0(node) or self.is_terminal_n1(node)
+
+    def is_terminal_n1(self, node: _bdd.Function | int) -> bool:
+        """Check if the node is the terminal node 1 (n1)."""
+        return node == self.get_terminal_node_n1()
+
+    def is_terminal_n0(self, node: _bdd.Function | int) -> bool:
+        """Check if the node is the terminal node 0 (n0)."""
+        return node == self.get_terminal_node_n0()
+
+    def get_high_node(self, node: _bdd.Function | int) -> Optional[_bdd.Function | int]:
+        """Return the high (right, solid) node."""
+        _, _, high = self._bdd.succ(node)
+        return high
+
+    def get_low_node(self, node: _bdd.Function | int) -> Optional[_bdd.Function | int]:
+        """Return the low (left, dashed) node."""
+        _, low, _ = self._bdd.succ(node)
+        return low
+
+    def get_value(self, node: _bdd.Function | int, complemented: bool = False) -> int:
+        """Return the value (id) of the node considering complemented arcs."""
+        value = int(node)
+        if self.is_terminal_n0(node):
+            value = 1 if complemented else 0
+        elif self.is_terminal_n1(node):
+            value = 0 if complemented else 1
+        return value
+
+    def pretty_node_str(self, node: _bdd.Function | int) -> str:
+        return f'{self.var(node)} ' \
+               f'(id: {self.get_value(node)}) ' \
+               f'(level: {self.level(node)}) ' \
+               f'(index: {self.index(node)}) '
+
+    def __str__(self) -> str:
+        result = 'Binary Decision Diagram (BDD):\n'
+        result += f'Instance class: {type(self._bdd)}\n'
+        result += f'#Nodes: {self.nof_nodes()}\n'
+        result += f'Root: {self.pretty_node_str(self.root)}\n'
+        levels_vars = dict(sorted(self._levels_variables.items(), key=lambda item: item[0]))
+        for level, var in levels_vars.items():
+            node = self.get_node(var)
+            result += f' |-{self.pretty_node_str(node)}\n'
+        result += f'Terminal node (n0): {self.pretty_node_str(self.get_terminal_node_n0())}\n'
+        result += f'Terminal node (n1): {self.pretty_node_str(self.get_terminal_node_n1())}\n'
+        return result

{flamapy-bdd-1.0.1.dev0 → flamapy-bdd-2.0.0.dev1}/flamapy/metamodels/bdd_metamodel/models/utils/__init__.py

@@ -5,4 +5,4 @@ from .txtcnf import (
 )
 
 
-__all__ = ['CNFLogicConnective', 'TextCNFNotation', 'TextCNFModel']
+__all__ = ['CNFLogicConnective', 'TextCNFNotation', 'TextCNFModel']