flamapy 2.0.0.dev4__tar.gz → 2.1.0.dev0__tar.gz

{flamapy-2.0.0.dev4 → flamapy-2.1.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flamapy
-Version: 2.0.0.dev4
+Version: 2.1.0.dev0
 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

{flamapy-2.0.0.dev4 → flamapy-2.1.0.dev0}/flamapy/commands/__init__.py

@@ -9,19 +9,21 @@ 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
 
 
@@ -38,17 +40,20 @@ def extract_commands(cls: type) -> List[Tuple[str, str, FunctionType, List[inspe
     return commands
 
 
-@command('generate_plugin', """This command generates a new plugin to implement your 
+@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'))
+         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/'
+    src = "skel_metamodel/"
 
     # Check DST exist
     if not os.path.isdir(dst):
@@ -70,42 +75,48 @@ def generate_plugin(args):  # type: ignore
 
     copy_files = copytree(src, dst, dirs_exist_ok=True)
 
-    for copy_file in Path(copy_files).glob('**/*'):
+    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)
+                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}'))
+    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)
+        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 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__)
+                    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.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)
 
 
@@ -120,7 +131,7 @@ def setup_manual_commands(subparsers, manual_commands):  # type: ignore
 
 def execute_command(args: argparse.Namespace) -> None:
     try:
-        if hasattr(args, 'method_name'):
+        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}
@@ -130,7 +141,7 @@ def execute_command(args: argparse.Namespace) -> None:
                 print(result)
         else:
             func = args.func
-            command_args = {k: v for k, v in vars(args).items() if k != '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)
@@ -147,8 +158,8 @@ def execute_command(args: argparse.Namespace) -> None:
 
 
 def flamapy_cli() -> None:
-    parser = argparse.ArgumentParser(description='FLAMA Feature Model CLI')
-    subparsers = parser.add_subparsers(dest='command')
+    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)
@@ -165,4 +176,4 @@ def flamapy_cli() -> None:
         print("Framework developers operations:")
         for name, description, _, _ in MANUAL_COMMANDS:
             print(f"  {name}: {description}")
-        print("Execute flamapy --help for more information")
+        print("Execute flamapy --help for more information")

flamapy-2.1.0.dev0/flamapy/interfaces/python/__init__.py

@@ -0,0 +1,3 @@
+from .flamapy_feature_model import FLAMAFeatureModel
+
+__all__ = ["FLAMAFeatureModel"]

{flamapy-2.0.0.dev4 → flamapy-2.1.0.dev0}/flamapy/interfaces/python/flamapy_feature_model.py

@@ -5,11 +5,10 @@ from flamapy.core.exceptions import FlamaException
 from flamapy.metamodels.configuration_metamodel.models import Configuration
 
 
-class FLAMAFeatureModel: 
-
+class FLAMAFeatureModel:
     def __init__(self, model_path: str):
         """
-        This is the path in the filesystem where the model is located. 
+        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
@@ -28,7 +27,7 @@ class FLAMAFeatureModel:
         self.bdd_model = None
 
     def _read(self, model_path: str) -> FeatureModel:
-        return self.discover_metamodel.use_transformation_t2m(model_path, 'fm')
+        return self.discover_metamodel.use_transformation_t2m(model_path, "fm")
 
     def _transform_to_sat(self) -> None:
         if self.sat_model is None:
@@ -39,17 +38,18 @@ class FLAMAFeatureModel:
             self.bdd_model = self.discover_metamodel.use_transformation_m2m(self.fm_model, "bdd")
 
     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. 
-        If the model does not follow the UVL specification, an 
+        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.
         """
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            atomic_sets = self.discover_metamodel.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 = []
@@ -62,66 +62,69 @@ class FLAMAFeatureModel:
             return None
 
     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 
-        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 
+        """
+        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.
         """
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            result = self.discover_metamodel.use_operation(self.fm_model,
-                                                           'FMAverageBranchingFactor').get_result()
+            result = self.discover_metamodel.use_operation(
+                self.fm_model, "FMAverageBranchingFactor"
+            ).get_result()
             return result
         except FlamaException as exception:
             print(f"Error: {exception}")
             return None
 
     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 
+        """
+        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.
         """
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            result = self.discover_metamodel.use_operation(self.fm_model,
-                                                           'FMCountLeafs').get_result()
+            result = self.discover_metamodel.use_operation(
+                self.fm_model, "FMCountLeafs"
+            ).get_result()
             return result
         except FlamaException as exception:
             print(f"Error: {exception}")
             return None
 
     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 
-         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.
+        """
+        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.
         """
 
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
             result = self.discover_metamodel.use_operation(
-                self.fm_model, 'FMEstimatedConfigurationsNumber').get_result()
+                self.fm_model, "FMEstimatedConfigurationsNumber"
+            ).get_result()
             return result
         except FlamaException as exception:
             print(f"Error: {exception}")
             return None
 
     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. 
+        """
+        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.
-        '''
+        """
         # Try to use the Find operation, which returns the atomic sets if they are found
         try:
-            operation = self.discover_metamodel.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()
@@ -134,22 +137,23 @@ class FLAMAFeatureModel:
             return None
 
     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 
+        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             
+        Traditionally you would use the flama tool by
         features = discover_metamodel.use_operation_from_file('OperationString', model)
-        however, in this tool we know that this operation is from the fm metamodel, 
+        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.discover_metamodel.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)
@@ -159,34 +163,36 @@ class FLAMAFeatureModel:
             return None
 
     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. 
-        If the model does not follow the UVL specification, an 
+        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.
         """
 
         # Try to use the Find operation, which returns the max depth of the tree
         try:
-            return self.discover_metamodel.use_operation(self.fm_model,
-                                                         'FMMaxDepthTree').get_result()
+            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.
+    # 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. 
+        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. 
+        flamapy that does not requires sat. please use the framework in case of needing it.
         """
         try:
             self._transform_to_sat()
-            features = self.discover_metamodel.use_operation(self.sat_model,
-                                                             'PySATCoreFeatures').get_result()
+            features = self.discover_metamodel.use_operation(
+                self.sat_model, "PySATCoreFeatures"
+            ).get_result()
             return features
         except FlamaException as exception:
             print(f"Error: {exception}")
@@ -194,14 +200,15 @@ class FLAMAFeatureModel:
 
     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 
+        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.
         """
         try:
             self._transform_to_sat()
-            features = self.discover_metamodel.use_operation(self.sat_model,
-                                                             'PySATDeadFeatures').get_result()
+            features = self.discover_metamodel.use_operation(
+                self.sat_model, "PySATDeadFeatures"
+            ).get_result()
             return features
         except FlamaException as exception:
             print(f"Error: {exception}")
@@ -209,14 +216,15 @@ class FLAMAFeatureModel:
 
     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, 
+        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.
         """
         try:
             self._transform_to_sat()
-            operation = self.discover_metamodel.get_operation(self.sat_model,
-                                                              'PySATFalseOptionalFeatures')
+            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()
@@ -227,15 +235,16 @@ class FLAMAFeatureModel:
 
     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 
+        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.discover_metamodel.use_transformation_t2m(configuration_path,
-                                                                           'configuration')
-            operation = self.discover_metamodel.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()
@@ -246,9 +255,9 @@ class FLAMAFeatureModel:
 
     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 
+        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:
@@ -256,12 +265,12 @@ class FLAMAFeatureModel:
             if with_sat:
                 self._transform_to_sat()
                 nop = self.discover_metamodel.use_operation(
-                    self.sat_model, 'PySATConfigurationsNumber'
+                    self.sat_model, "PySATConfigurationsNumber"
                 ).get_result()
             else:
                 self._transform_to_bdd()
                 nop = self.discover_metamodel.use_operation(
-                    self.bdd_model, 'BDDConfigurationsNumber'
+                    self.bdd_model, "BDDConfigurationsNumber"
                 ).get_result()
             return nop
         except FlamaException as exception:
@@ -270,22 +279,22 @@ class FLAMAFeatureModel:
 
     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 
+        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 = []
             if with_sat:
                 self._transform_to_sat()
-                products = self.discover_metamodel.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.discover_metamodel.use_operation(self.bdd_model,
-                                                                 'BDDConfigurations'
-                                                                 ).get_result()
+                products = self.discover_metamodel.use_operation(
+                    self.bdd_model, "BDDConfigurations"
+                ).get_result()
             return products
         except FlamaException as exception:
             print(f"Error: {exception}")
@@ -293,16 +302,17 @@ class FLAMAFeatureModel:
 
     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 
+        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.
         """
         try:
             self._transform_to_sat()
-            configuration = self.discover_metamodel.use_transformation_t2m(configuration_path,
-                                                                           'configuration')
+            configuration = self.discover_metamodel.use_transformation_t2m(
+                configuration_path, "configuration"
+            )
 
-            operation = self.discover_metamodel.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()
@@ -310,25 +320,28 @@ class FLAMAFeatureModel:
             print(f"Error: {exception}")
             return None
 
-    def satisfiable_configuration(self, 
-                                  configuration_path: str, 
-                                  full_configuration: bool = False) -> Union[None, bool]:
+    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 
+        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.discover_metamodel.use_transformation_t2m(configuration_path, 
-                                                                           'configuration')
-            operation = self.discover_metamodel.get_operation(self.sat_model, 
-                                                              'PySATSatisfiableConfiguration')
+            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)
+                configuration.is_full = True
             else:
-                operation.set_configuration(configuration, is_full=False)
+                configuration.is_full = False
 
+            operation.set_configuration(configuration)
             operation.execute(self.sat_model)
             result = operation.get_result()
             return result
@@ -338,15 +351,16 @@ class FLAMAFeatureModel:
 
     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 
+        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.
         """
         try:
             self._transform_to_sat()
-            result = self.discover_metamodel.use_operation(self.sat_model,
-                                                           'PySATSatisfiable').get_result()
+            result = self.discover_metamodel.use_operation(
+                self.sat_model, "PySATSatisfiable"
+            ).get_result()
             return result
         except FlamaException as exception:
             print(f"Error: {exception}")
-            return None
+            return None

{flamapy-2.0.0.dev4 → flamapy-2.1.0.dev0}/flamapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flamapy
-Version: 2.0.0.dev4
+Version: 2.1.0.dev0
 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

{flamapy-2.0.0.dev4 → flamapy-2.1.0.dev0}/flamapy.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 README.md
+pyproject.toml
 setup.py
 flamapy.egg-info/PKG-INFO
 flamapy.egg-info/SOURCES.txt

flamapy-2.1.0.dev0/flamapy.egg-info/requires.txt

@@ -0,0 +1,12 @@
+wheel
+flamapy-fw~=2.1.0.dev0
+flamapy-fm~=2.1.0.dev0
+flamapy-sat~=2.1.0.dev0
+flamapy-bdd~=2.1.0.dev0
+
+[dev]
+pytest
+pytest-mock
+prospector
+mypy
+coverage

flamapy-2.1.0.dev0/pyproject.toml

@@ -0,0 +1,55 @@
+[tool.ruff]
+line-length = 100  # Matches max-line-length from pycodestyle
+target-version = "py38"  # Adjust if using another Python version
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "C", "PL", "RUF"]  # Includes pycodestyle, pylint, and McCabe complexity
+ignore = [
+    "RUF012",  # Equivalent to Pylint's super-init-not-called
+    "RUF002", # Weird symbols on docstring
+    "RUF001", # Weird symbols string
+]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10  # Equivalent to enabling mccabe in Prospector
+
+[tool.ruff.lint.per-file-ignores]
+"flamapy/metamodels/fm_metamodel/transformations/pysat_to_fm.py" = ["ALL"]  # Ignore this file entirely
+"tests/*" = ["ALL"]  # Ignore all test files
+"build/*" = ["ALL"]
+"resources/*" = ["ALL"]
+".mypy_cache/*" = ["ALL"]
+"venv/*" = ["ALL"]
+".venv/*" = ["ALL"]
+"env/*" = ["ALL"]
+"flamapy_fm.egg-info/*" = ["ALL"]
+"__pycache__/*" = ["ALL"]
+"skel_metamodel/*" = ["ALL"]
+"flamapy/__init__.py" = ["ALL"]
+
+[tool.ruff.lint.pycodestyle]
+max-line-length = 100  # Matches your existing pycodestyle setting
+
+# MYPY CONFIGURATION
+[tool.mypy]
+scripts_are_modules = true
+show_traceback = true
+
+# Strict checking
+check_untyped_defs = true
+disallow_untyped_defs = true
+disallow_any_generics = true
+warn_no_return = true
+strict_optional = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+
+# Show error codes for type: ignore comments
+show_error_codes = true
+
+# Suppress missing imports errors
+ignore_missing_imports = true
+
+# Warn about unreachable or redundant code
+warn_unreachable = true

{flamapy-2.0.0.dev4 → flamapy-2.1.0.dev0}/setup.py

@@ -4,10 +4,12 @@ import setuptools
 with open("README.md", "r") as fh:
     long_description = fh.read()
 
+
 def read_requirements(file):
     with open(file, "r") as fh:
         return fh.read().splitlines()
 
+
 # Read requirements from the requirements.txt file
 requirements = read_requirements("requirements.txt")
 
@@ -16,27 +18,28 @@ dev_requirements = read_requirements("requirements-dev.txt")
 
 setuptools.setup(
     name="flamapy",
-    version="2.0.0.dev4",
+    version="2.1.0.dev0",
     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.",
+    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.",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/flamapy/flamapy-feature-model",
-    packages=setuptools.find_namespace_packages(include=['flamapy.*']),
+    packages=setuptools.find_namespace_packages(include=["flamapy.*"]),
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
         "Operating System :: OS Independent",
     ],
-    python_requires='>=3.9',
+    python_requires=">=3.9",
     install_requires=requirements,
-    extras_require={
-        'dev': dev_requirements
-    },
+    extras_require={"dev": dev_requirements},
     entry_points={
-        'console_scripts': [
-            'flamapy = flamapy.commands:flamapy_cli',
+        "console_scripts": [
+            "flamapy = flamapy.commands:flamapy_cli",
         ],
     },
 )

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

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

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

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