flamapy 2.0.0.dev2__tar.gz → 2.0.0.dev3__tar.gz

flamapy-2.0.0.dev3/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.1
+Name: flamapy
+Version: 2.0.0.dev3
+Summary: Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richier API and a complete command line interface and documentation.
+Home-page: https://github.com/flamapy/flamapy-feature-model
+Author: Flamapy
+Author-email: flamapy@us.es
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+
+<div align="center">
+
+  <a href="">[![Pytest Testing Suite](https://github.com/flamapy/flamapy/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/tests.yml)</a>
+  <a href="">[![Commits Syntax Checker](https://github.com/flamapy/flamapy/actions/workflows/commits.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/commits.yml)</a>
+  <a href="">![PyPI](https://img.shields.io/pypi/v/flamapy?label=pypi%20package)
+  <a href="">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy)
+</div>
+
+# 
+
+<div id="top"></div>
+<br />
+<div align="center">
+
+  <h3 align="center">FLAMAPY</h3>
+
+  <p align="center">
+    A new and easy way to use FLAMA
+    <br />
+    <a href="https://github.com/flamapy/flamapy/issues">Report Bug</a>
+    ·
+    <a href="https://github.com/flamapy/flamapy/issues">Request Feature</a>
+  </p>
+</div>
+<!-- ABOUT THE PROJECT -->
+
+# About The Project
+FLAMAPY Feature model distribution provides an easier way of using FLAMAPY when analysing feature models. It packs the most used plugins for analyis of feature models adding a layer of convenience to use the framework or integrate it. If some other operations are required please see in the [documentation](flamapy.github.io/docs) if its supported in the ecosystem though the Python interface. 
+
+Feature Model Analysis has a crucial role in software product line engineering, enabling us to understand, design, and validate the complex relationships among features in a software product line. These feature models can often be complex and challenging to analyze due to their variability, making it difficult to identify conflicts, dead features, and potential optimizations. This is where this distribution comes in.
+
+# Using the CMD
+```bash
+flamapy --help #This will show the commands available
+flamapy satisfiable <path to file> to check if a model is valid
+...
+```
+# Using the Python interface
+This is simple, Flama FM dist in hosted in pypi, therefore simply add the package flama-fm-dist to your requirements file and call the API as follows:
+
+```python
+from flamapy.interfaces.python.flama_feature_model import FLAMAFeatureModel
+
+fm = FLAMAFeatureModel("path/to/feature/model")
+print(fm.valid())
+```
+# Operations available:
+Currently this distribution offers a subset of the operations available in the ecosystem, in the case of the feature mdoel distribution, we provide those operations that are well tested and used by the community. Nonetheless, If other more complex operations are required you can rely on the python interface of the framework to execute them all. 
+
+* atomic_sets: This operation is used to find the atomic sets in a model: It returns the atomic sets if they are found in the model. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* average_branching_factor:This refers to the average number of child features that a parent feature has in a feature model. It's calculated by dividing the total number of child features by the total number of parent features. A high average branching factor indicates a complex feature model with many options, while a low average branching factor indicates a simpler model.
+
+* commonality: This is a measure of how often a feature appears in the products of a product line. It's usually expressed as a percentage. A feature with 100 per cent commonality is a core feature, as it appears in all products.
+
+* configurations: These are the individual outcomes that can be produced from a feature model. Each product is a combination of features that satisfies all the constraints and dependencies in the feature model.
+
+* configurations_number: This is the total number of different full configurations that can be produced from a feature model. It's calculated by considering all possible combinations of features, taking into account the constraints and dependencies between features.
+
+* core_features: These are the features that are present in all products of a product line. In a feature model, they are the  features that are mandatory and not optional. Core features define the commonality among all products in a product line. This call requires sat to be called, however, there is an implementation within flamapy that does not requires sat, please use the framework in case of needing it.
+
+* count_leafs: This operation counts the number of leaf features in a feature model. Leaf features are those that do not have any child features. They represent the most specific options in a product line.
+* dead_features: These are features that, due to the constraints and dependencies in the feature model, cannot be included in any valid product. Dead features are usually a sign of an error in the feature model.
+
+* estimated_number_of_configurations: This is an estimate of the total number of different products that can be produced from a feature model. It's calculated by considering all possible combinations of features. This can be a simple multiplication if all
+features are independent, but in most cases, constraints and dependencies between features need to be taken into account.
+
+* false_optional_features: These are features that appear to be optional in the feature model, but due to the constraints and dependencies, must be included in every valid product. Like dead features, false optional features are usually a sign of an error in the feature model.
+
+* feature_ancestors: These are the features that are directly or indirectly the parent of a given feature in a feature model. Ancestors of a feature are found by traversing up the feature hierarchy. This information can be useful to understand the context and dependencies of a feature.
+
+* filter: This operation selects a subset of the products of a product line based on certain criteria. For example, youmight filter the products to only include those that contain a certain feature.
+
+* leaf_features: This operation is used to find leaf features in a model: It returns the leaf features if they are found in themodel. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* max_depth: This operation is used to find the max depth of the tree in a model: It returns the max depth of the tree. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* satisfiable: In the context of feature models, this usually refers to whether the feature model itself satisfies all the
+constraints and dependencies. A a valid feature model is one that does encodes at least a single valid product.
+
+* satisfiable_configuration: This is a product that is produced from a valid configuration of features. A valid product satisfies all the constraints and dependencies in the feature model.
+
+
+

flamapy-2.0.0.dev3/README.md

@@ -0,0 +1,82 @@
+<div align="center">
+
+  <a href="">[![Pytest Testing Suite](https://github.com/flamapy/flamapy/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/tests.yml)</a>
+  <a href="">[![Commits Syntax Checker](https://github.com/flamapy/flamapy/actions/workflows/commits.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/commits.yml)</a>
+  <a href="">![PyPI](https://img.shields.io/pypi/v/flamapy?label=pypi%20package)
+  <a href="">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy)
+</div>
+
+# 
+
+<div id="top"></div>
+<br />
+<div align="center">
+
+  <h3 align="center">FLAMAPY</h3>
+
+  <p align="center">
+    A new and easy way to use FLAMA
+    <br />
+    <a href="https://github.com/flamapy/flamapy/issues">Report Bug</a>
+    ·
+    <a href="https://github.com/flamapy/flamapy/issues">Request Feature</a>
+  </p>
+</div>
+<!-- ABOUT THE PROJECT -->
+
+# About The Project
+FLAMAPY Feature model distribution provides an easier way of using FLAMAPY when analysing feature models. It packs the most used plugins for analyis of feature models adding a layer of convenience to use the framework or integrate it. If some other operations are required please see in the [documentation](flamapy.github.io/docs) if its supported in the ecosystem though the Python interface. 
+
+Feature Model Analysis has a crucial role in software product line engineering, enabling us to understand, design, and validate the complex relationships among features in a software product line. These feature models can often be complex and challenging to analyze due to their variability, making it difficult to identify conflicts, dead features, and potential optimizations. This is where this distribution comes in.
+
+# Using the CMD
+```bash
+flamapy --help #This will show the commands available
+flamapy satisfiable <path to file> to check if a model is valid
+...
+```
+# Using the Python interface
+This is simple, Flama FM dist in hosted in pypi, therefore simply add the package flama-fm-dist to your requirements file and call the API as follows:
+
+```python
+from flamapy.interfaces.python.flama_feature_model import FLAMAFeatureModel
+
+fm = FLAMAFeatureModel("path/to/feature/model")
+print(fm.valid())
+```
+# Operations available:
+Currently this distribution offers a subset of the operations available in the ecosystem, in the case of the feature mdoel distribution, we provide those operations that are well tested and used by the community. Nonetheless, If other more complex operations are required you can rely on the python interface of the framework to execute them all. 
+
+* atomic_sets: This operation is used to find the atomic sets in a model: It returns the atomic sets if they are found in the model. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* average_branching_factor:This refers to the average number of child features that a parent feature has in a feature model. It's calculated by dividing the total number of child features by the total number of parent features. A high average branching factor indicates a complex feature model with many options, while a low average branching factor indicates a simpler model.
+
+* commonality: This is a measure of how often a feature appears in the products of a product line. It's usually expressed as a percentage. A feature with 100 per cent commonality is a core feature, as it appears in all products.
+
+* configurations: These are the individual outcomes that can be produced from a feature model. Each product is a combination of features that satisfies all the constraints and dependencies in the feature model.
+
+* configurations_number: This is the total number of different full configurations that can be produced from a feature model. It's calculated by considering all possible combinations of features, taking into account the constraints and dependencies between features.
+
+* core_features: These are the features that are present in all products of a product line. In a feature model, they are the  features that are mandatory and not optional. Core features define the commonality among all products in a product line. This call requires sat to be called, however, there is an implementation within flamapy that does not requires sat, please use the framework in case of needing it.
+
+* count_leafs: This operation counts the number of leaf features in a feature model. Leaf features are those that do not have any child features. They represent the most specific options in a product line.
+* dead_features: These are features that, due to the constraints and dependencies in the feature model, cannot be included in any valid product. Dead features are usually a sign of an error in the feature model.
+
+* estimated_number_of_configurations: This is an estimate of the total number of different products that can be produced from a feature model. It's calculated by considering all possible combinations of features. This can be a simple multiplication if all
+features are independent, but in most cases, constraints and dependencies between features need to be taken into account.
+
+* false_optional_features: These are features that appear to be optional in the feature model, but due to the constraints and dependencies, must be included in every valid product. Like dead features, false optional features are usually a sign of an error in the feature model.
+
+* feature_ancestors: These are the features that are directly or indirectly the parent of a given feature in a feature model. Ancestors of a feature are found by traversing up the feature hierarchy. This information can be useful to understand the context and dependencies of a feature.
+
+* filter: This operation selects a subset of the products of a product line based on certain criteria. For example, youmight filter the products to only include those that contain a certain feature.
+
+* leaf_features: This operation is used to find leaf features in a model: It returns the leaf features if they are found in themodel. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* max_depth: This operation is used to find the max depth of the tree in a model: It returns the max depth of the tree. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* satisfiable: In the context of feature models, this usually refers to whether the feature model itself satisfies all the
+constraints and dependencies. A a valid feature model is one that does encodes at least a single valid product.
+
+* satisfiable_configuration: This is a product that is produced from a valid configuration of features. A valid product satisfies all the constraints and dependencies in the feature model.
+

flamapy-2.0.0.dev3/flamapy/commands/__init__.py

@@ -0,0 +1,168 @@
+import argparse
+import os
+import sys
+from functools import wraps
+import inspect
+from pathlib import Path
+from shutil import copytree
+from typing import List, Tuple, Optional
+from types import FunctionType
+
+from flamapy.interfaces.python.flamapy_feature_model import FLAMAFeatureModel
+# List to store registered commands and their arguments
+MANUAL_COMMANDS = []
+
+
+def command(name, description, *args):  # type: ignore
+
+    def decorator(func):  # type: ignore
+        MANUAL_COMMANDS.append((name, description, func, args))
+
+        @wraps(func)
+        def wrapper(*func_args, **func_kwargs):  # type: ignore
+            return func(*func_args, **func_kwargs)
+        return wrapper
+    return decorator
+
+
+def extract_commands(cls: type) -> List[Tuple[str, str, FunctionType, List[inspect.Parameter]]]:
+    commands = []
+    for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
+        if name.startswith("_"):
+            continue
+        docstring: Optional[str] = method.__doc__
+        signature = inspect.signature(method)
+        # Exclude 'self' from parameters
+        parameters = list(signature.parameters.values())[1:]  # Skip 'self'
+        commands.append((name, docstring or "", method, parameters))
+    return commands
+
+
+@command('generate_plugin', """This command generates a new plugin to implement your 
+         cusom operations. To execute it you should set yourself in the path of the
+         flamapy src directory""", 
+         ('name', str, 'The pluggins name'),
+         ('extension', str, 'The extansion to be registered with the flamapy ecosystem'),
+         ('path', str, 'The path to generate it'))
+def generate_plugin(args):  # type: ignore
+    name = args.name
+    ext = args.extension
+    dst = args.path
+    src = 'skel_metamodel/'
+
+    # Check DST exist
+    if not os.path.isdir(dst):
+        print(f"Folder {dst} not exist")
+        sys.exit()
+
+    # Check DST is empty
+    if len(os.listdir(dst)) != 0:
+        print(f"Folder {dst} is not empty")
+        sys.exit()
+
+    # Check DST has permissions to WRITE
+    if not os.access(dst, os.W_OK):
+        print(f"Folder {dst} has not write permissions")
+        sys.exit()
+
+    # Generating structure
+    print("Generating structure ...")
+
+    copy_files = copytree(src, dst, dirs_exist_ok=True)
+
+    for copy_file in Path(copy_files).glob('**/*'):
+        if copy_file.is_dir():
+            continue
+        with open(copy_file, "r", encoding="utf-8") as file:
+            lines = file.readlines()
+        with open(copy_file, "w", encoding="utf-8") as filewrite:
+            for line in lines:
+                out_line = line.replace('__NAME__', name.capitalize()).replace('__EXT__', ext)
+                filewrite.write(out_line)
+
+    os.rename(os.path.join(dst, 'flamapy/metamodels/__NAME__'),
+              os.path.join(dst, f'flamapy/metamodels/{name}'))
+    print("Plugin generated!")
+
+
+def setup_dynamic_commands(subparsers, dynamic_commands):  # type: ignore
+    for name, docstring, method, parameters in dynamic_commands:
+        subparser = subparsers.add_parser(name, help=docstring)
+        subparser.add_argument('model_path', type=str, help='Path to the feature model file')
+        if 'configuration_path' in [param.name for param in parameters]:
+            subparser.add_argument('--configuration_path', 
+                                   type=str, 
+                                   help='Path to the configuration file', 
+                                   required=False)
+        for param in parameters:
+            arg_name = param.name
+            if arg_name not in ['model_path']:  # Avoid duplicates
+                if param.default == param.empty:  # Positional argument
+                    subparser.add_argument(arg_name, 
+                                           type=param.annotation, 
+                                           help=param.annotation.__name__)
+                else:  # Optional argument
+                    subparser.add_argument(f'--{arg_name}', 
+                                           type=param.annotation, 
+                                           default=param.default, 
+                                           help=f'Optional {param.annotation.__name__}')
+        subparser.set_defaults(func=method, method_name=name, parameters=parameters)
+
+
+def setup_manual_commands(subparsers, manual_commands):  # type: ignore
+    for name, description, func, args in manual_commands:
+        subparser = subparsers.add_parser(name, help=description)
+        for arg in args:
+            arg_name, arg_type, arg_help = arg
+            subparser.add_argument(arg_name, type=arg_type, help=arg_help)
+        subparser.set_defaults(func=func)
+
+
+def execute_command(args: argparse.Namespace) -> None:
+    try:
+        if hasattr(args, 'method_name'):
+            cls_instance = FLAMAFeatureModel(args.model_path)
+            method_parameters = [param.name for param in args.parameters]
+            command_args = {k: v for k, v in vars(args).items() if k in method_parameters}
+            method = getattr(cls_instance, args.method_name)
+            result = method(**command_args)
+            if result is not None:
+                print(result)
+        else:
+            func = args.func
+            command_args = {k: v for k, v in vars(args).items() if k != 'func'}
+            result = func(args)
+            if result is not None:
+                print(result)
+    except FileNotFoundError as fnf_error:
+        print(f"File not found error: {fnf_error}")
+    except TypeError as type_error:
+        print(f"Type error: {type_error}")
+    except ValueError as value_error:
+        print(f"Value error: {value_error}")
+    except KeyError as key_error:
+        print(f"Key error: {key_error}")
+    except AttributeError as attr_error:
+        print(f"Attribute error: {attr_error}")
+
+
+def flamapy_cli() -> None:
+    parser = argparse.ArgumentParser(description='FLAMA Feature Model CLI')
+    subparsers = parser.add_subparsers(dest='command')
+
+    dynamic_commands = extract_commands(FLAMAFeatureModel)
+    setup_dynamic_commands(subparsers, dynamic_commands)
+    setup_manual_commands(subparsers, MANUAL_COMMANDS)
+
+    args = parser.parse_args()
+
+    if args.command:
+        execute_command(args)
+    else:
+        print("Feature model operations:")
+        for name, docstring, _, _ in dynamic_commands:
+            print(f"  {name}: {docstring}")
+        print("Framework developers operations:")
+        for name, description, _, _ in MANUAL_COMMANDS:
+            print(f"  {name}: {description}")
+        print("Execute flamapy --help for more information")

flamapy-2.0.0.dev3/flamapy/interfaces/python/__init__.py

@@ -0,0 +1,5 @@
+from .flamapy_feature_model import (
+    FLAMAFeatureModel
+)
+
+__all__ = ['FLAMAFeatureModel']

flamapy-2.0.0.dev2/flamapy/interfaces/python/FLAMAFeatureModel.py → flamapy-2.0.0.dev3/flamapy/interfaces/python/flamapy_feature_model.py

@@ -1,47 +1,44 @@
+from typing import List, Any, Union
 from flamapy.core.discover import DiscoverMetamodels
 from flamapy.metamodels.fm_metamodel.models import FeatureModel
-from typing import Optional
+from flamapy.core.exceptions import FlamaException
+from flamapy.metamodels.configuration_metamodel.models import Configuration
 
-class FLAMAFeatureModel():
 
-    def __init__(self, model_path:str, configuration_path:Optional[str]=None):
+class FLAMAFeatureModel: 
+
+    def __init__(self, model_path: str):
         """
         This is the path in the filesystem where the model is located. 
         Any model in UVL, FaMaXML or FeatureIDE format are accepted
         """
-        self.model_path=model_path
-        """
-        This is the path in the filesystem where the configuration is located. 
-        Only CSV format are accepted (see documentation for more information)
-        """
-        self.configuration_path=configuration_path
+        self.model_path = model_path
         """
         Creating the interface witht he flama framework
         """
-        self.dm = DiscoverMetamodels()
+        self.discover_metamodel = DiscoverMetamodels()
         """
         We save the model for later ussage
         """
-        self.fm_model=self._read(model_path)
+        self.fm_model = self._read(model_path)
         """
         We create a empty sat model and a bdd model to avoid double transformations
         """
-        self.sat_model=None
-        self.bdd_model=None
+        self.sat_model = None
+        self.bdd_model = None
 
+    def _read(self, model_path: str) -> FeatureModel:
+        return self.discover_metamodel.use_transformation_t2m(model_path, 'fm')
 
-    def _read(self, model_path)->FeatureModel:
-        return self.dm.use_transformation_t2m(model_path,'fm')
-    
-    def _transform_to_sat(self):
+    def _transform_to_sat(self) -> None:
         if self.sat_model is None:
-            self.sat_model=self.dm.use_transformation_m2m(self.fm_model,"pysat")
-    
-    def _transform_to_bdd(self):
+            self.sat_model = self.discover_metamodel.use_transformation_m2m(self.fm_model, "pysat")
+
+    def _transform_to_bdd(self) -> None:
         if self.bdd_model is None:
-            self.bdd_model=self.dm.use_transformation_m2m(self.fm_model,"bdd")
+            self.bdd_model = self.discover_metamodel.use_transformation_m2m(self.fm_model, "bdd")
 
-    def atomic_sets(self):
+    def atomic_sets(self) -> Union[None, List[List[Any]]]:
         """ 
         This operation is used to find the atomic sets in a model:
         It returns the atomic sets if they are found in the model. 
@@ -51,7 +48,8 @@ class FLAMAFeatureModel():
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            atomic_sets = self.dm.use_operation(self.fm_model,'FMAtomicSets').get_result()
+            atomic_sets = self.discover_metamodel.use_operation(self.fm_model,
+                                                                'FMAtomicSets').get_result()
             result = []
             for atomic_set in atomic_sets:
                 partial_set = []
@@ -59,12 +57,11 @@ class FLAMAFeatureModel():
                     partial_set.append(feature.name)
                 result.append(partial_set)
             return result
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-        
-    def average_branching_factor(self):
+    def average_branching_factor(self) -> Union[None, float]:
         """ 
         This refers to the average number of child features that a parent feature has in a 
         feature model. It's calculated by dividing the total number of child features by the 
@@ -75,14 +72,14 @@ class FLAMAFeatureModel():
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            result = self.dm.use_operation(self.fm_model,'FMAverageBranchingFactor').get_result()
+            result = self.discover_metamodel.use_operation(self.fm_model,
+                                                           'FMAverageBranchingFactor').get_result()
             return result
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-        
-    def count_leafs(self):
+    def count_leafs(self) -> Union[None, int]:
         """ 
         This operation counts the number of leaf features in a feature model. Leaf features 
         are those that do not have any child features. They represent the most specific 
@@ -91,14 +88,14 @@ class FLAMAFeatureModel():
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            result = self.dm.use_operation(self.fm_model,'FMCountLeafs').get_result()
+            result = self.discover_metamodel.use_operation(self.fm_model,
+                                                           'FMCountLeafs').get_result()
             return result
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-        
-    def estimated_number_of_configurations(self):
+    def estimated_number_of_configurations(self) -> Union[None, int]:
         """ 
          This is an estimate of the total number of different products that can be produced 
          from a feature model. It's calculated by considering all possible combinations of 
@@ -109,14 +106,14 @@ class FLAMAFeatureModel():
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            result = self.dm.use_operation(self.fm_model,'FMEstimatedConfigurationsNumber').get_result()
+            result = self.discover_metamodel.use_operation(
+                self.fm_model, 'FMEstimatedConfigurationsNumber').get_result()
             return result
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def feature_ancestors(self,feature_name:str):
+    def feature_ancestors(self, feature_name: str) -> Union[None, List[str]]:
         ''' 
         These are the features that are directly or indirectly the parent of a given feature in 
         a feature model. Ancestors of a feature are found by traversing up the feature hierarchy. 
@@ -124,7 +121,7 @@ class FLAMAFeatureModel():
         '''
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            operation = self.dm.get_operation(self.fm_model,'FMFeatureAncestors')
+            operation = self.discover_metamodel.get_operation(self.fm_model, 'FMFeatureAncestors')
             operation.set_feature(self.fm_model.get_feature_by_name(feature_name))
             operation.execute(self.fm_model)
             flama_result = operation.get_result()
@@ -132,38 +129,36 @@ class FLAMAFeatureModel():
             for res in flama_result:
                 result.append(res.name)
             return result
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-
-    def leaf_features(self):
+    def leaf_features(self) -> Union[None, List[str]]:
         """ 
         This operation is used to find leaf features in a model:
         It returns the leaf features if they are found in the model. 
         If the model does not follow the UVL specification, an 
         exception is raised and the operation returns False.
-        
+
         Traditionally you would use the flama tool by             
-        features = dm.use_operation_from_file('OperationString', model)
+        features = discover_metamodel.use_operation_from_file('OperationString', model)
         however, in this tool we know that this operation is from the fm metamodel, 
         so we avoid to execute the transformation if possible
         """
 
         # Try to use the operation, which returns the leaf features if they are found
         try:
-            features = self.dm.use_operation(self.fm_model,'FMLeafFeatures').get_result()
+            features = self.discover_metamodel.use_operation(self.fm_model,
+                                                             'FMLeafFeatures').get_result()
             leaf_features = []
             for feature in features:
                 leaf_features.append(feature.name)
             return leaf_features
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def max_depth(self):
+    def max_depth(self) -> Union[None, int]:
         """ 
         This operation is used to find the max depth of the tree in a model:
         It returns the max depth of the tree. 
@@ -173,32 +168,31 @@ class FLAMAFeatureModel():
 
         # Try to use the Find operation, which returns the max depth of the tree
         try:
-            return self.dm.use_operation(self.fm_model,'FMMaxDepthTree').get_result()
-        except Exception as e:
-            print(f"Error: {e}")
+            return self.discover_metamodel.use_operation(self.fm_model,
+                                                         'FMMaxDepthTree').get_result()
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-    """
-    The methods above rely on sat to be executed.
-    """
-
-    def core_features(self):
+    #The methods above rely on sat to be executed.
+    def core_features(self) -> Union[None, List[str]]:
         """
-        These are the features that are present in all products of a product line. In a feature model, 
-        they are the features that are mandatory and not optional. Core features define the commonality 
-        among all products in a product line. This call requires sat to be called, however, there is 
-        an implementation within flama that does not requires sat. please use the framework in case of needing it. 
+        These are the features that are present in all products of a product line. 
+        In a feature model, they are the features that are mandatory and not optional. 
+        Core features define the commonality among all products in a product line. 
+        This call requires sat to be called, however, there is an implementation within
+        flamapy that does not requires sat. please use the framework in case of needing it. 
         """
         try:
             self._transform_to_sat()
-            features = self.dm.use_operation(self.sat_model,'PySATCoreFeatures').get_result()
+            features = self.discover_metamodel.use_operation(self.sat_model,
+                                                             'PySATCoreFeatures').get_result()
             return features
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-        
-    def dead_features(self):
+    def dead_features(self) -> Union[None, List[str]]:
         """
         These are features that, due to the constraints and dependencies in the 
         feature model, cannot be included in any valid product. Dead features are usually 
@@ -206,14 +200,14 @@ class FLAMAFeatureModel():
         """
         try:
             self._transform_to_sat()
-            features = self.dm.use_operation(self.sat_model,'PySATDeadFeatures').get_result()
+            features = self.discover_metamodel.use_operation(self.sat_model,
+                                                             'PySATDeadFeatures').get_result()
             return features
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def false_optional_features(self):
+    def false_optional_features(self) -> Union[None, List[str]]:
         """
         These are features that appear to be optional in the feature model, but due to the 
         constraints and dependencies, must be included in every valid product. Like dead features, 
@@ -221,120 +215,128 @@ class FLAMAFeatureModel():
         """
         try:
             self._transform_to_sat()
-
-            operation = self.dm.get_operation(self.sat_model,'PySATFalseOptionalFeatures')
-            operation.feature_model=self.fm_model
+            operation = self.discover_metamodel.get_operation(self.sat_model,
+                                                              'PySATFalseOptionalFeatures')
+            operation.feature_model = self.fm_model
             operation.execute(self.sat_model)
             features = operation.get_result()
             return features
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def filter(self, configurationPath:str):
+    def filter(self, configuration_path: str) -> Union[None, List[Configuration]]:
         """
-        This operation selects a subset of the products of a product line based on certain criteria. 
-        For example, you might filter the products to only include those that contain a certain feature.
+        This operation selects a subset of the products of a product line based on certain 
+        criteria. For example, you might filter the products to only include those that 
+        contain a certain feature.
         """
         try:
             self._transform_to_sat()
-            configuration = self.dm.use_transformation_t2m(configurationPath,'configuration')
-
-            operation = self.dm.get_operation(self.sat_model,'PySATFilter')
+            configuration = self.discover_metamodel.use_transformation_t2m(configuration_path,
+                                                                           'configuration')
+            operation = self.discover_metamodel.get_operation(self.sat_model, 'PySATFilter')
             operation.set_configuration(configuration)
             operation.execute(self.sat_model)
             result = operation.get_result()
             return result
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def configurations_number(self, with_sat:bool=False):
+    def configurations_number(self, with_sat: bool = False) -> Union[None, int]:
         """
-        This is the total number of different full configurations that can be produced from a feature model. 
-        It's calculated by considering all possible combinations of features, taking into account 
-        the constraints and dependencies between features.
+        This is the total number of different full configurations that can be 
+        produced from a feature model. It's calculated by considering all possible 
+        combinations of features, taking into account the constraints and 
+        dependencies between features.
         """
         try:
-            nop=0
+            nop = 0
             if with_sat:
                 self._transform_to_sat()
-                nop = self.dm.use_operation(self.sat_model,'PySATConfigurationsNumber').get_result()
-                
+                nop = self.discover_metamodel.use_operation(
+                    self.sat_model, 'PySATConfigurationsNumber'
+                ).get_result()
             else:
                 self._transform_to_bdd()
-                nop = self.dm.use_operation(self.bdd_model,'BDDConfigurationsNumber').get_result()
+                nop = self.discover_metamodel.use_operation(
+                    self.bdd_model, 'BDDConfigurationsNumber'
+                ).get_result()
             return nop
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def configurations(self, with_sat:bool=False):
+    def configurations(self, with_sat: bool = False) -> Union[None, List[Configuration]]:
         """
         These are the individual outcomes that can be produced from a feature model. Each product 
         is a combination of features that satisfies all the constraints and dependencies in the 
         feature model.
         """
         try:
-            products=[]
+            products = []
             if with_sat:
                 self._transform_to_sat()
-                products = self.dm.use_operation(self.sat_model,'PySATConfigurations').get_result()
+                products = self.discover_metamodel.use_operation(self.sat_model,
+                                                                 'PySATConfigurations'
+                                                                 ).get_result()
             else:
                 self._transform_to_bdd()
-                products = self.dm.use_operation(self.bdd_model,'BDDConfigurations').get_result()
+                products = self.discover_metamodel.use_operation(self.bdd_model,
+                                                                 'BDDConfigurations'
+                                                                 ).get_result()
             return products
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def commonality(self, configurationPath:str):
+    def commonality(self, configuration_path: str) -> Union[None, float]:
         """
         This is a measure of how often a feature appears in the products of a 
         product line. It's usually expressed as a percentage. A feature with 
-        100% commonality is a core feature, as it appears in all products.
+        100 per cent commonality is a core feature, as it appears in all products.
         """
         try:
             self._transform_to_sat()
-            configuration = self.dm.use_transformation_t2m(configurationPath,'configuration')
+            configuration = self.discover_metamodel.use_transformation_t2m(configuration_path,
+                                                                           'configuration')
 
-            operation = self.dm.get_operation(self.sat_model,'PySATCommonality')
+            operation = self.discover_metamodel.get_operation(self.sat_model, 'PySATCommonality')
             operation.set_configuration(configuration)
             operation.execute(self.sat_model)
             return operation.get_result()
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def satisfiable_configuration(self, configurationPath:str, full_configuration:bool=False):
+    def satisfiable_configuration(self, 
+                                  configuration_path: str, 
+                                  full_configuration: bool = False) -> Union[None, bool]:
         """
         This is a product that is produced from a valid configuration of features. A valid 
         product satisfies all the constraints and dependencies in the feature model.
         """
         try:
             self._transform_to_sat()
-            configuration = self.dm.use_transformation_t2m(configurationPath,'configuration')
-            operation = self.dm.get_operation(self.sat_model,'PySATSatisfiableConfiguration')
-            print(operation)
+            configuration = self.discover_metamodel.use_transformation_t2m(configuration_path, 
+                                                                           'configuration')
+            operation = self.discover_metamodel.get_operation(self.sat_model, 
+                                                              'PySATSatisfiableConfiguration')
+
             if full_configuration:
                 operation.set_configuration(configuration, is_full=True)
             else:
                 operation.set_configuration(configuration, is_full=False)
-                
+
             operation.execute(self.sat_model)
             result = operation.get_result()
             return result
-        except Exception as e:
-            print(f"Error: {e}")
+        except FlamaException as exception:
+            print(f"Error: {exception}")
             return None
 
-
-    def satisfiable(self):
+    def satisfiable(self) -> Union[None, bool]:
         """
         In the context of feature models, this usually refers to whether the feature model itself 
         satisfies all the constraints and dependencies. A a valid feature model is one that 
@@ -342,10 +344,9 @@ class FLAMAFeatureModel():
         """
         try:
             self._transform_to_sat()
-            result = self.dm.use_operation(self.sat_model,'PySATSatisfiable').get_result()
+            result = self.discover_metamodel.use_operation(self.sat_model,
+                                                           'PySATSatisfiable').get_result()
             return result
-        except Exception as e:
-            print(f"Error: {e}")
-            return None
-
-
+        except FlamaException as exception:
+            print(f"Error: {exception}")
+            return None

flamapy-2.0.0.dev3/flamapy.egg-info/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.1
+Name: flamapy
+Version: 2.0.0.dev3
+Summary: Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richier API and a complete command line interface and documentation.
+Home-page: https://github.com/flamapy/flamapy-feature-model
+Author: Flamapy
+Author-email: flamapy@us.es
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+
+<div align="center">
+
+  <a href="">[![Pytest Testing Suite](https://github.com/flamapy/flamapy/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/tests.yml)</a>
+  <a href="">[![Commits Syntax Checker](https://github.com/flamapy/flamapy/actions/workflows/commits.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/commits.yml)</a>
+  <a href="">![PyPI](https://img.shields.io/pypi/v/flamapy?label=pypi%20package)
+  <a href="">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy)
+</div>
+
+# 
+
+<div id="top"></div>
+<br />
+<div align="center">
+
+  <h3 align="center">FLAMAPY</h3>
+
+  <p align="center">
+    A new and easy way to use FLAMA
+    <br />
+    <a href="https://github.com/flamapy/flamapy/issues">Report Bug</a>
+    ·
+    <a href="https://github.com/flamapy/flamapy/issues">Request Feature</a>
+  </p>
+</div>
+<!-- ABOUT THE PROJECT -->
+
+# About The Project
+FLAMAPY Feature model distribution provides an easier way of using FLAMAPY when analysing feature models. It packs the most used plugins for analyis of feature models adding a layer of convenience to use the framework or integrate it. If some other operations are required please see in the [documentation](flamapy.github.io/docs) if its supported in the ecosystem though the Python interface. 
+
+Feature Model Analysis has a crucial role in software product line engineering, enabling us to understand, design, and validate the complex relationships among features in a software product line. These feature models can often be complex and challenging to analyze due to their variability, making it difficult to identify conflicts, dead features, and potential optimizations. This is where this distribution comes in.
+
+# Using the CMD
+```bash
+flamapy --help #This will show the commands available
+flamapy satisfiable <path to file> to check if a model is valid
+...
+```
+# Using the Python interface
+This is simple, Flama FM dist in hosted in pypi, therefore simply add the package flama-fm-dist to your requirements file and call the API as follows:
+
+```python
+from flamapy.interfaces.python.flama_feature_model import FLAMAFeatureModel
+
+fm = FLAMAFeatureModel("path/to/feature/model")
+print(fm.valid())
+```
+# Operations available:
+Currently this distribution offers a subset of the operations available in the ecosystem, in the case of the feature mdoel distribution, we provide those operations that are well tested and used by the community. Nonetheless, If other more complex operations are required you can rely on the python interface of the framework to execute them all. 
+
+* atomic_sets: This operation is used to find the atomic sets in a model: It returns the atomic sets if they are found in the model. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* average_branching_factor:This refers to the average number of child features that a parent feature has in a feature model. It's calculated by dividing the total number of child features by the total number of parent features. A high average branching factor indicates a complex feature model with many options, while a low average branching factor indicates a simpler model.
+
+* commonality: This is a measure of how often a feature appears in the products of a product line. It's usually expressed as a percentage. A feature with 100 per cent commonality is a core feature, as it appears in all products.
+
+* configurations: These are the individual outcomes that can be produced from a feature model. Each product is a combination of features that satisfies all the constraints and dependencies in the feature model.
+
+* configurations_number: This is the total number of different full configurations that can be produced from a feature model. It's calculated by considering all possible combinations of features, taking into account the constraints and dependencies between features.
+
+* core_features: These are the features that are present in all products of a product line. In a feature model, they are the  features that are mandatory and not optional. Core features define the commonality among all products in a product line. This call requires sat to be called, however, there is an implementation within flamapy that does not requires sat, please use the framework in case of needing it.
+
+* count_leafs: This operation counts the number of leaf features in a feature model. Leaf features are those that do not have any child features. They represent the most specific options in a product line.
+* dead_features: These are features that, due to the constraints and dependencies in the feature model, cannot be included in any valid product. Dead features are usually a sign of an error in the feature model.
+
+* estimated_number_of_configurations: This is an estimate of the total number of different products that can be produced from a feature model. It's calculated by considering all possible combinations of features. This can be a simple multiplication if all
+features are independent, but in most cases, constraints and dependencies between features need to be taken into account.
+
+* false_optional_features: These are features that appear to be optional in the feature model, but due to the constraints and dependencies, must be included in every valid product. Like dead features, false optional features are usually a sign of an error in the feature model.
+
+* feature_ancestors: These are the features that are directly or indirectly the parent of a given feature in a feature model. Ancestors of a feature are found by traversing up the feature hierarchy. This information can be useful to understand the context and dependencies of a feature.
+
+* filter: This operation selects a subset of the products of a product line based on certain criteria. For example, youmight filter the products to only include those that contain a certain feature.
+
+* leaf_features: This operation is used to find leaf features in a model: It returns the leaf features if they are found in themodel. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* max_depth: This operation is used to find the max depth of the tree in a model: It returns the max depth of the tree. If the model does not follow the UVL specification, an exception is raised and the operation returns False.
+
+* satisfiable: In the context of feature models, this usually refers to whether the feature model itself satisfies all the
+constraints and dependencies. A a valid feature model is one that does encodes at least a single valid product.
+
+* satisfiable_configuration: This is a product that is produced from a valid configuration of features. A valid product satisfies all the constraints and dependencies in the feature model.
+
+
+

{flamapy-2.0.0.dev2 → flamapy-2.0.0.dev3}/flamapy.egg-info/SOURCES.txt

@@ -6,6 +6,6 @@ flamapy.egg-info/dependency_links.txt
 flamapy.egg-info/entry_points.txt
 flamapy.egg-info/requires.txt
 flamapy.egg-info/top_level.txt
-flamapy/interfaces/__init__.py
-flamapy/interfaces/python/FLAMAFeatureModel.py
-flamapy/interfaces/python/__init__.py
+flamapy/commands/__init__.py
+flamapy/interfaces/python/__init__.py
+flamapy/interfaces/python/flamapy_feature_model.py

flamapy-2.0.0.dev3/flamapy.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+flamapy = flamapy.commands:flamapy_cli
+

flamapy-2.0.0.dev3/flamapy.egg-info/requires.txt

@@ -0,0 +1,12 @@
+wheel
+flamapy-fw==2.0.0.dev6
+flamapy-fm==2.0.0.dev7
+flamapy-sat==2.0.0.dev7
+flamapy-bdd==2.0.0.dev9
+
+[dev]
+pytest
+pytest-mock
+prospector
+mypy
+coverage

{flamapy-2.0.0.dev2 → flamapy-2.0.0.dev3}/setup.py

@@ -16,7 +16,7 @@ dev_requirements = read_requirements("requirements-dev.txt")
 
 setuptools.setup(
     name="flamapy",
-    version="2.0.0.dev2",
+    version="2.0.0.dev3",
     author="Flamapy",
     author_email="flamapy@us.es",
     description="Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richier API and a complete command line interface and documentation.",
@@ -36,7 +36,7 @@ setuptools.setup(
     },
     entry_points={
         'console_scripts': [
-            'flamapy-fm-cli = flamapy.interfaces.command_line:flama_fm',
+            'flamapy = flamapy.commands:flamapy_cli',
         ],
     },
 )

flamapy-2.0.0.dev2/PKG-INFO

@@ -1,84 +0,0 @@
-Metadata-Version: 2.1
-Name: flamapy
-Version: 2.0.0.dev2
-Summary: Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richier API and a complete command line interface and documentation.
-Home-page: https://github.com/flamapy/flamapy-feature-model
-Author: Flamapy
-Author-email: flamapy@us.es
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-
-<div align="center">
-
-  <a href="">[![Pytest Testing Suite](https://github.com/flamapy/flamapy/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/tests.yml)</a>
-  <a href="">[![Commits Syntax Checker](https://github.com/flamapy/flamapy/actions/workflows/commits.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/commits.yml)</a>
-  <a href="">![PyPI](https://img.shields.io/pypi/v/flamapy?label=pypi%20package)
-  <a href="">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy)
-</div>
-
-# 
-
-<div id="top"></div>
-<br />
-<div align="center">
-
-  <h3 align="center">FLAMAPY</h3>
-
-  <p align="center">
-    A new and easy way to use FLAMA
-    <br />
-    <a href="https://github.com/flamapy/flamapy/issues">Report Bug</a>
-    ·
-    <a href="https://github.com/flamapy/flamapy/issues">Request Feature</a>
-  </p>
-</div>
-<!-- ABOUT THE PROJECT -->
-
-## About The Project
-
-FLAMAPY Feature model distribution provides an easier way of using FLAMA when analysing feature models. It packs the most used plugins for analyis of feature models adding a layer of convenience to use the framework or integrate it. 
-
-Feature Model Analysis has a crucial role in software product line engineering, enabling us to understand, design, and validate the complex relationships among features in a software product line. These feature models can often be complex and challenging to analyze due to their variability, making it difficult to identify conflicts, dead features, and potential optimizations. This is where this distribution comes in.
-
-# Soon comming, easy to use CMD
-## TODO
-
-# Using the Python interface
-This is simple, Flama FM dist in hosted in pypi, therefore simply add the package flama-fm-dist to your requirements file and call the API as follows:
-
-```python
-from flamapy.interfaces.python.FLAMAFeatureModel import FLAMAFeatureModel
-
-fm = FLAMAFeatureModel("path/to/feature/model")
-print(fm.valid())
-```
-Currently the operations provided by this distribution are: 
-* atomic_sets: This operation is used to find the atomic sets in a model. It returns the atomic sets if they are found in the model. If the model does not follow the UVL specification, an         exception is raised and the operation returns False.
-* average_branching_factor: This refers to the average number of child features that a parent feature has in a feature model. It's calculated by dividing the total number of child features by the total number of parent features. A high average branching factor indicates a complex       feature model with many options, while a low average branching factor indicates a simpler model.
-* count_leafs: This operation counts the number of leaf features in a feature model. Leaf features are those that do not have any child features. They represent the most specific options in a product line.
-* estimated_number_of_products: This is an estimate of the total number of different products that can be produced from a feature model. It's calculated by considering all possible combinations of  features. This can be a simple multiplication if all features are independent, but in most cases, constraints and dependencies between features need to be taken into account.
-* feature_ancestors: These are the features that are directly or indirectly the parent of a given feature in a feature model. Ancestors of a feature are found by traversing up the feature hierarchy. This information can be useful to understand the context and dependencies of a feature.
-* leaf_features: This operation is used to find leaf features in a model. It returns the leaf features if they are found in the model. If the model does not follow the UVL specification, an 
-exception is raised and the operation returns False.   
-* max_dept:  This operation is used to find the max depth of the tree in a model.It returns the max depth of the tree. 
-* commonality: This is a measure of how often a feature appears in the products of a product line. It's usually expressed as a percentage. A feature with 100% commonality is a core feature, as it appears in all products.
-* core_features: These are the features that are present in all products of a product line. In a feature model, they are the features that are mandatory and not optional. Core features define the commonality among all products in a product line. This call requires sat to be called, however, there is an implementation within flama that does not requires sat. please use the framework in case of needing it. 
-* dead_features: These are features that, due to the constraints and dependencies in the feature model, cannot be included in any valid product. Dead features are usually a sign of an error in the feature model.
-* error_detection: This refers to the process of identifying and locating errors in a feature model. Errors can include things like dead features, false optional features, or contradictions in the constraints.
-* false_optional_features: These are features that appear to be optional in the feature model, but due to the constraints and dependencies, must be included in every valid product. Like dead features, false optional features are usually a sign of an error in the feature model.
-* filter: This operation selects a subset of the products of a product line based on certain criteria. For example, you might filter the products to only include those that contain a certain feature.
-* products number: This is the total number of different products that can be produced from a feature model.It's calculated by considering all possible combinations of features, taking into account the constraints and dependencies between features.
-* products: This operation returns all the products of a product line. A product is a valid combination of features that can be produced from a feature model. The products are returned as a list of lists, where each inner list represents a product and contains the features that are included in that product.
-* valid_configuration: This operation checks if a given configuration is valid in a feature model. A configuration is a list of features that are included in a product. The operation returns True if the configuration is valid, and False if it's not.
-* valid_product: This operation checks if a given product (full configuration) is valid in a feature model. A product is a list of features that are included in a product. The operation returns True if the product is valid, and False if it's not.
-* valid: This operation checks if a feature model is valid. A feature model is valid if it follows the UVL specification. The operation returns True if the feature model is valid, and False if it's not.
-
-
-
-

flamapy-2.0.0.dev2/README.md

@@ -1,66 +0,0 @@
-<div align="center">
-
-  <a href="">[![Pytest Testing Suite](https://github.com/flamapy/flamapy/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/tests.yml)</a>
-  <a href="">[![Commits Syntax Checker](https://github.com/flamapy/flamapy/actions/workflows/commits.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/commits.yml)</a>
-  <a href="">![PyPI](https://img.shields.io/pypi/v/flamapy?label=pypi%20package)
-  <a href="">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy)
-</div>
-
-# 
-
-<div id="top"></div>
-<br />
-<div align="center">
-
-  <h3 align="center">FLAMAPY</h3>
-
-  <p align="center">
-    A new and easy way to use FLAMA
-    <br />
-    <a href="https://github.com/flamapy/flamapy/issues">Report Bug</a>
-    ·
-    <a href="https://github.com/flamapy/flamapy/issues">Request Feature</a>
-  </p>
-</div>
-<!-- ABOUT THE PROJECT -->
-
-## About The Project
-
-FLAMAPY Feature model distribution provides an easier way of using FLAMA when analysing feature models. It packs the most used plugins for analyis of feature models adding a layer of convenience to use the framework or integrate it. 
-
-Feature Model Analysis has a crucial role in software product line engineering, enabling us to understand, design, and validate the complex relationships among features in a software product line. These feature models can often be complex and challenging to analyze due to their variability, making it difficult to identify conflicts, dead features, and potential optimizations. This is where this distribution comes in.
-
-# Soon comming, easy to use CMD
-## TODO
-
-# Using the Python interface
-This is simple, Flama FM dist in hosted in pypi, therefore simply add the package flama-fm-dist to your requirements file and call the API as follows:
-
-```python
-from flamapy.interfaces.python.FLAMAFeatureModel import FLAMAFeatureModel
-
-fm = FLAMAFeatureModel("path/to/feature/model")
-print(fm.valid())
-```
-Currently the operations provided by this distribution are: 
-* atomic_sets: This operation is used to find the atomic sets in a model. It returns the atomic sets if they are found in the model. If the model does not follow the UVL specification, an         exception is raised and the operation returns False.
-* average_branching_factor: This refers to the average number of child features that a parent feature has in a feature model. It's calculated by dividing the total number of child features by the total number of parent features. A high average branching factor indicates a complex       feature model with many options, while a low average branching factor indicates a simpler model.
-* count_leafs: This operation counts the number of leaf features in a feature model. Leaf features are those that do not have any child features. They represent the most specific options in a product line.
-* estimated_number_of_products: This is an estimate of the total number of different products that can be produced from a feature model. It's calculated by considering all possible combinations of  features. This can be a simple multiplication if all features are independent, but in most cases, constraints and dependencies between features need to be taken into account.
-* feature_ancestors: These are the features that are directly or indirectly the parent of a given feature in a feature model. Ancestors of a feature are found by traversing up the feature hierarchy. This information can be useful to understand the context and dependencies of a feature.
-* leaf_features: This operation is used to find leaf features in a model. It returns the leaf features if they are found in the model. If the model does not follow the UVL specification, an 
-exception is raised and the operation returns False.   
-* max_dept:  This operation is used to find the max depth of the tree in a model.It returns the max depth of the tree. 
-* commonality: This is a measure of how often a feature appears in the products of a product line. It's usually expressed as a percentage. A feature with 100% commonality is a core feature, as it appears in all products.
-* core_features: These are the features that are present in all products of a product line. In a feature model, they are the features that are mandatory and not optional. Core features define the commonality among all products in a product line. This call requires sat to be called, however, there is an implementation within flama that does not requires sat. please use the framework in case of needing it. 
-* dead_features: These are features that, due to the constraints and dependencies in the feature model, cannot be included in any valid product. Dead features are usually a sign of an error in the feature model.
-* error_detection: This refers to the process of identifying and locating errors in a feature model. Errors can include things like dead features, false optional features, or contradictions in the constraints.
-* false_optional_features: These are features that appear to be optional in the feature model, but due to the constraints and dependencies, must be included in every valid product. Like dead features, false optional features are usually a sign of an error in the feature model.
-* filter: This operation selects a subset of the products of a product line based on certain criteria. For example, you might filter the products to only include those that contain a certain feature.
-* products number: This is the total number of different products that can be produced from a feature model.It's calculated by considering all possible combinations of features, taking into account the constraints and dependencies between features.
-* products: This operation returns all the products of a product line. A product is a valid combination of features that can be produced from a feature model. The products are returned as a list of lists, where each inner list represents a product and contains the features that are included in that product.
-* valid_configuration: This operation checks if a given configuration is valid in a feature model. A configuration is a list of features that are included in a product. The operation returns True if the configuration is valid, and False if it's not.
-* valid_product: This operation checks if a given product (full configuration) is valid in a feature model. A product is a list of features that are included in a product. The operation returns True if the product is valid, and False if it's not.
-* valid: This operation checks if a feature model is valid. A feature model is valid if it follows the UVL specification. The operation returns True if the feature model is valid, and False if it's not.
-
-

flamapy-2.0.0.dev2/flamapy.egg-info/PKG-INFO

@@ -1,84 +0,0 @@
-Metadata-Version: 2.1
-Name: flamapy
-Version: 2.0.0.dev2
-Summary: Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richier API and a complete command line interface and documentation.
-Home-page: https://github.com/flamapy/flamapy-feature-model
-Author: Flamapy
-Author-email: flamapy@us.es
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-
-<div align="center">
-
-  <a href="">[![Pytest Testing Suite](https://github.com/flamapy/flamapy/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/tests.yml)</a>
-  <a href="">[![Commits Syntax Checker](https://github.com/flamapy/flamapy/actions/workflows/commits.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy/actions/workflows/commits.yml)</a>
-  <a href="">![PyPI](https://img.shields.io/pypi/v/flamapy?label=pypi%20package)
-  <a href="">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy)
-</div>
-
-# 
-
-<div id="top"></div>
-<br />
-<div align="center">
-
-  <h3 align="center">FLAMAPY</h3>
-
-  <p align="center">
-    A new and easy way to use FLAMA
-    <br />
-    <a href="https://github.com/flamapy/flamapy/issues">Report Bug</a>
-    ·
-    <a href="https://github.com/flamapy/flamapy/issues">Request Feature</a>
-  </p>
-</div>
-<!-- ABOUT THE PROJECT -->
-
-## About The Project
-
-FLAMAPY Feature model distribution provides an easier way of using FLAMA when analysing feature models. It packs the most used plugins for analyis of feature models adding a layer of convenience to use the framework or integrate it. 
-
-Feature Model Analysis has a crucial role in software product line engineering, enabling us to understand, design, and validate the complex relationships among features in a software product line. These feature models can often be complex and challenging to analyze due to their variability, making it difficult to identify conflicts, dead features, and potential optimizations. This is where this distribution comes in.
-
-# Soon comming, easy to use CMD
-## TODO
-
-# Using the Python interface
-This is simple, Flama FM dist in hosted in pypi, therefore simply add the package flama-fm-dist to your requirements file and call the API as follows:
-
-```python
-from flamapy.interfaces.python.FLAMAFeatureModel import FLAMAFeatureModel
-
-fm = FLAMAFeatureModel("path/to/feature/model")
-print(fm.valid())
-```
-Currently the operations provided by this distribution are: 
-* atomic_sets: This operation is used to find the atomic sets in a model. It returns the atomic sets if they are found in the model. If the model does not follow the UVL specification, an         exception is raised and the operation returns False.
-* average_branching_factor: This refers to the average number of child features that a parent feature has in a feature model. It's calculated by dividing the total number of child features by the total number of parent features. A high average branching factor indicates a complex       feature model with many options, while a low average branching factor indicates a simpler model.
-* count_leafs: This operation counts the number of leaf features in a feature model. Leaf features are those that do not have any child features. They represent the most specific options in a product line.
-* estimated_number_of_products: This is an estimate of the total number of different products that can be produced from a feature model. It's calculated by considering all possible combinations of  features. This can be a simple multiplication if all features are independent, but in most cases, constraints and dependencies between features need to be taken into account.
-* feature_ancestors: These are the features that are directly or indirectly the parent of a given feature in a feature model. Ancestors of a feature are found by traversing up the feature hierarchy. This information can be useful to understand the context and dependencies of a feature.
-* leaf_features: This operation is used to find leaf features in a model. It returns the leaf features if they are found in the model. If the model does not follow the UVL specification, an 
-exception is raised and the operation returns False.   
-* max_dept:  This operation is used to find the max depth of the tree in a model.It returns the max depth of the tree. 
-* commonality: This is a measure of how often a feature appears in the products of a product line. It's usually expressed as a percentage. A feature with 100% commonality is a core feature, as it appears in all products.
-* core_features: These are the features that are present in all products of a product line. In a feature model, they are the features that are mandatory and not optional. Core features define the commonality among all products in a product line. This call requires sat to be called, however, there is an implementation within flama that does not requires sat. please use the framework in case of needing it. 
-* dead_features: These are features that, due to the constraints and dependencies in the feature model, cannot be included in any valid product. Dead features are usually a sign of an error in the feature model.
-* error_detection: This refers to the process of identifying and locating errors in a feature model. Errors can include things like dead features, false optional features, or contradictions in the constraints.
-* false_optional_features: These are features that appear to be optional in the feature model, but due to the constraints and dependencies, must be included in every valid product. Like dead features, false optional features are usually a sign of an error in the feature model.
-* filter: This operation selects a subset of the products of a product line based on certain criteria. For example, you might filter the products to only include those that contain a certain feature.
-* products number: This is the total number of different products that can be produced from a feature model.It's calculated by considering all possible combinations of features, taking into account the constraints and dependencies between features.
-* products: This operation returns all the products of a product line. A product is a valid combination of features that can be produced from a feature model. The products are returned as a list of lists, where each inner list represents a product and contains the features that are included in that product.
-* valid_configuration: This operation checks if a given configuration is valid in a feature model. A configuration is a list of features that are included in a product. The operation returns True if the configuration is valid, and False if it's not.
-* valid_product: This operation checks if a given product (full configuration) is valid in a feature model. A product is a list of features that are included in a product. The operation returns True if the product is valid, and False if it's not.
-* valid: This operation checks if a feature model is valid. A feature model is valid if it follows the UVL specification. The operation returns True if the feature model is valid, and False if it's not.
-
-
-
-

flamapy-2.0.0.dev2/flamapy.egg-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-flamapy-fm-cli = flamapy.interfaces.command_line:flama_fm
-

flamapy-2.0.0.dev2/flamapy.egg-info/requires.txt

@@ -1,12 +0,0 @@
-wheel
-flamapy-fw==2.0.0.dev2
-flamapy-fm==2.0.0.dev2
-flamapy-sat==2.0.0.dev2
-flamapy-bdd==2.0.0.dev1
-
-[dev]
-pytest
-pytest-mock
-prospector
-mypy
-coverage