flamapy-fm 2.0.0.dev1__tar.gz → 2.0.0.dev3__tar.gz

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flamapy-fm
-Version: 2.0.0.dev1
+Version: 2.0.0.dev3
 Summary: flamapy-fm is a plugin to Flamapy module
 Home-page: https://github.com/flamapy/fm_metamodel
 Author: Flamapy

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/models/feature_model.py

@@ -275,14 +275,14 @@ class Constraint:
         (i.e., it can be transformed to a set of simple constraints)."""
         split_ctcs = split_constraint(self)
         return len(split_ctcs) > 1 and all(
-            self.is_simple_constraint() for ctc in split_ctcs
+            ctc.is_simple_constraint() for ctc in split_ctcs
         )
 
     def is_strictcomplex_constraint(self) -> bool:
         """Return true if the constraint is a strict-complex constraint
         (i.e., it cannot be transformed to a set of simple constraints)."""
         split_ctcs = split_constraint(self)
-        return any(self.is_complex_constraint() for ctc in split_ctcs)
+        return any(ctc.is_complex_constraint() for ctc in split_ctcs)
 
     def __str__(self) -> str:
         return f"({self.name}) {str(self.ast)}"

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/operations/__init__.py

@@ -4,7 +4,8 @@ from .fm_leaf_features import FMLeafFeatures, get_leaf_features
 from .fm_average_branching_factor import FMAverageBranchingFactor, average_branching_factor
 from .fm_feature_ancestors import FMFeatureAncestors, get_feature_ancestors
 from .fm_max_depth_tree import FMMaxDepthTree, max_depth_tree
-from .fm_estimated_configurations_number import FMEstimatedConfigurationsNumber, count_configurations
+from .fm_estimated_configurations_number import FMEstimatedConfigurationsNumber, \
+    count_configurations
 from .fm_atomic_sets import FMAtomicSets, get_atomic_sets
 from .fm_metrics import FMMetrics
 from .fm_generate_random_attribute import GenerateRandomAttribute

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/operations/fm_estimated_configurations_number.py

@@ -19,7 +19,7 @@ class FMEstimatedConfigurationsNumber(EstimatedConfigurationsNumber):
         self.result = 0
         self.feature_model: Optional[FeatureModel] = None
 
-    def execute(self, model: VariabilityModel) -> 'FMEstimatedProductsNumber':
+    def execute(self, model: VariabilityModel) -> 'FMEstimatedConfigurationsNumber':
         self.feature_model = cast(FeatureModel, model)
         self.result = self.get_configurations_number()
         return self

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/operations/fm_metrics.py

@@ -70,6 +70,7 @@ class FMMetrics(Metrics):  # pylint: disable=too-many-instance-attributes
             if callable(getattr(self, method_name))
             and hasattr(getattr(self, method_name), "_is_metric_method")
         ]
+
         if self.filter is not None:
             metric_methods = [
                 method for method in metric_methods if method.__name__ in self.filter

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/transformations/clafer_writer.py

@@ -1,6 +1,6 @@
 import re
 from enum import Enum
-from typing import Any
+from typing import Any, Optional
 
 from flamapy.core.transformations import ModelToText
 from flamapy.core.models.ast import ASTOperation
@@ -93,7 +93,7 @@ def read_feature_attributes(feature: Feature, tab_count: int) -> str:
     return result
 
 
-def parse_group_type(feature: Feature) -> str | None:
+def parse_group_type(feature: Feature) -> Optional[str]:
     group_type = None
     if feature.is_alternative_group():
         group_type = 'xor'
@@ -134,8 +134,8 @@ def attributes_definition(feature_model: FeatureModel) -> str:
     result = ''
     if attributes:
         result = f'abstract {ATTRIBUTED_FEATURE}\n'
-        for name, type in attributes.items():
-            result += f'\t{name} -> {type}\n'
+        for name, v_type in attributes.items():
+            result += f'\t{name} -> {v_type}\n'
     return result
 
 

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/transformations/json_reader.py

@@ -1,6 +1,6 @@
 import functools
 import json
-from typing import Any 
+from typing import Any, Dict, List, Optional
 
 from flamapy.core.models.ast import Node, AST, ASTOperation
 from flamapy.core.exceptions import ParsingException
@@ -26,7 +26,7 @@ class JSONReader(TextToModel):
     def __init__(self, path: str) -> None:
         self.path = path
 
-    def transform(self) -> str:
+    def transform(self) -> FeatureModel:
         with open(self.path, 'r', encoding='utf-8') as file:
             data = json.load(file)
             features_info = data['features']
@@ -36,7 +36,7 @@ class JSONReader(TextToModel):
             return FeatureModel(root_feature, constraints)
 
     @staticmethod
-    def parse_json(json_content: str) -> FeatureModel:
+    def parse_json(json_content: Dict[str, Any]) -> FeatureModel:
         features_info = json_content['features']
         constraints_info = json_content['constraints']
         root_feature = parse_tree(None, features_info)
@@ -44,7 +44,7 @@ class JSONReader(TextToModel):
         return FeatureModel(root_feature, constraints)
 
 
-def parse_tree(parent: Feature, feature_node: dict[str, Any]) -> Feature:
+def parse_tree(parent: Optional[Feature], feature_node: Dict[str, Any]) -> Feature:
     """Parse the tree structure and returns the root feature."""
     feature_name = feature_node['name']
     is_abstract = feature_node['abstract']
@@ -55,20 +55,17 @@ def parse_tree(parent: Feature, feature_node: dict[str, Any]) -> Feature:
     return feature
 
 
-def parse_attributes(feature: Feature, feature_node: dict[str, Any]) -> None:
+def parse_attributes(feature: Feature, feature_node: Dict[str, Any]) -> None:
     if 'attributes' in feature_node:
         for attribute in feature_node['attributes']:
             attribute_name = attribute['name']
-            if 'value' in attribute:
-                attribute_value = attribute['value']
-            else:
-                attribute_value = None
+            attribute_value = attribute.get('value')
             attr = Attribute(attribute_name, None, attribute_value, None)
             attr.set_parent(feature)
             feature.add_attribute(attr)
 
 
-def parse_relations(feature: Feature, feature_node: dict[str, Any]) -> None:
+def parse_relations(feature: Feature, feature_node: Dict[str, Any]) -> None:
     if 'relations' in feature_node:
         for relation in feature_node['relations']:
             children = []
@@ -93,11 +90,10 @@ def parse_relations(feature: Feature, feature_node: dict[str, Any]) -> None:
             feature.add_relation(new_relation)
 
 
-def parse_constraints(constraints_info: dict[str, Any]) -> list[Constraint]:
+def parse_constraints(constraints_info: List[Dict[str, Any]]) -> List[Constraint]:
     constraints = []
     for ctc_info in constraints_info:
         name = ctc_info['name']
-        # ctc_expr = ctc_info['expr']  # not used
         ast_tree = ctc_info['ast']
         ctc_node = parse_ast_constraint(ast_tree)
         ctc = Constraint(name, AST(ctc_node))
@@ -105,7 +101,7 @@ def parse_constraints(constraints_info: dict[str, Any]) -> list[Constraint]:
     return constraints
 
 
-def parse_ast_constraint(ctc_info: dict[str, Any]) -> Node:
+def parse_ast_constraint(ctc_info: Dict[str, Any]) -> Node:
     ctc_type = ctc_info['type']
     ctc_operands = ctc_info['operands']
     node = None

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/transformations/json_writer.py

@@ -1,6 +1,6 @@
 import json
 from enum import Enum
-from typing import Any
+from typing import Any, Dict, List
 
 from flamapy.core.models.ast import Node
 from flamapy.core.transformations import ModelToText
@@ -40,21 +40,21 @@ class JSONWriter(ModelToText):
         return json.dumps(json_object, indent=4)
 
 
-def to_json(feature_model: FeatureModel) -> dict[str, Any]:
-    result: dict[str, Any] = {}
+def to_json(feature_model: FeatureModel) -> Dict[str, Any]:
+    result: Dict[str, Any] = {}
     result['features'] = get_tree_info(feature_model.root)
     result['constraints'] = get_constraints_info(feature_model.get_constraints())
     return result
 
 
-def get_tree_info(feature: Feature) -> dict[str, Any]:
-    feature_info = {}
+def get_tree_info(feature: Feature) -> Dict[str, Any]:
+    feature_info: Dict[str, Any] = {}
     feature_info['name'] = feature.name
-    feature_info['abstract'] = feature.is_abstract
+    feature_info['abstract'] = str(feature.is_abstract)
 
-    relations = []
+    relations: List[Dict[str, Any]] = []
     for relation in feature.get_relations():
-        relation_info = {}
+        relation_info: Dict[str, Any] = {}
         relation_type = JSONFeatureType.FEATURE.value
         if relation.is_alternative():
             relation_type = JSONFeatureType.XOR.value
@@ -71,7 +71,7 @@ def get_tree_info(feature: Feature) -> dict[str, Any]:
         relation_info['type'] = relation_type
         relation_info['card_min'] = relation.card_min
         relation_info['card_max'] = relation.card_max
-        children = []
+        children: List[Dict[str, Any]] = []
         for child in relation.children:
             children.append(get_tree_info(child))
         relation_info['children'] = children
@@ -86,10 +86,10 @@ def get_tree_info(feature: Feature) -> dict[str, Any]:
     return feature_info
 
 
-def get_attributes_info(attributes: list[Attribute]) -> list[dict[str, Any]]:
-    attributes_info = []
+def get_attributes_info(attributes: List[Attribute]) -> List[Dict[str, Any]]:
+    attributes_info: List[Dict[str, Any]] = []
     for attribute in attributes:
-        attr_info = {}
+        attr_info: Dict[str, Any] = {}
         attr_info['name'] = attribute.name
         if attribute.default_value is not None:
             attr_info['value'] = attribute.default_value
@@ -97,10 +97,10 @@ def get_attributes_info(attributes: list[Attribute]) -> list[dict[str, Any]]:
     return attributes_info
 
 
-def get_constraints_info(constraints: list[Constraint]) -> list[dict[str, Any]]:
-    constraints_info = []
+def get_constraints_info(constraints: List[Constraint]) -> List[Dict[str, Any]]:
+    constraints_info: List[Dict[str, Any]] = []
     for ctc in constraints:
-        ctc_info = {}
+        ctc_info: Dict[str, Any] = {}
         ctc_info['name'] = ctc.name
         ctc_info['expr'] = ctc.ast.pretty_str()
         ctc_info['ast'] = get_ctc_info(ctc.ast.root)
@@ -108,14 +108,14 @@ def get_constraints_info(constraints: list[Constraint]) -> list[dict[str, Any]]:
     return constraints_info
 
 
-def get_ctc_info(ast_node: Node) -> dict[str, Any]:
-    ctc_info: dict[str, Any] = {}
+def get_ctc_info(ast_node: Node) -> Dict[str, Any]:
+    ctc_info: Dict[str, Any] = {}
     if ast_node.is_term():
         ctc_info['type'] = JSONFeatureType.FEATURE.value
         ctc_info['operands'] = [ast_node.data]
     else:
         ctc_info['type'] = ast_node.data.value
-        operands = []
+        operands: List[Dict[str, Any]] = []
         left = get_ctc_info(ast_node.left)
         operands.append(left)
         if ast_node.right is not None:

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy/metamodels/fm_metamodel/transformations/pysat_to_fm.py

@@ -1,5 +1,5 @@
 import functools
-from typing import Optional
+from typing import Optional, Union
 
 from flamapy.core.models.ast import AST, Node, ASTOperation
 from flamapy.core.transformations import ModelToModel
@@ -62,7 +62,7 @@ class PysatToFM(ModelToModel):
         raise FlamaException('Error converting from SAT to FM. ',
                              'There is not candidate for the root feature.')
 
-    def _get_node_from_clause_term(self, term: Node | int) -> Node:
+    def _get_node_from_clause_term(self, term: Union[Node, int]) -> Node:
         if isinstance(term, Node):
             return term
         name = self.source_model.features[abs(term)]

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy_fm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flamapy-fm
-Version: 2.0.0.dev1
+Version: 2.0.0.dev3
 Summary: flamapy-fm is a plugin to Flamapy module
 Home-page: https://github.com/flamapy/fm_metamodel
 Author: Flamapy

flamapy-fm-2.0.0.dev3/flamapy_fm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/flamapy_fm.egg-info/requires.txt

@@ -1,6 +1,6 @@
-flamapy-fw~=2.0.0.dev1
-uvlparser~=2.0.1
-afmparser~=1.0.3
+flamapy-fw==2.0.0.dev3
+uvlparser==2.0.1
+afmparser==1.0.3
 
 [dev]
 pytest

{flamapy-fm-2.0.0.dev1 → flamapy-fm-2.0.0.dev3}/setup.py

@@ -4,10 +4,19 @@ 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")
+
+# Read development requirements from the dev-requirements.txt file
+dev_requirements = read_requirements("requirements-dev.txt")
 
 setuptools.setup(
     name="flamapy-fm",
-    version="2.0.0.dev1",
+    version="2.0.0.dev3",
     author="Flamapy",
     author_email="flamapy@us.es",
     description="flamapy-fm is a plugin to Flamapy module",
@@ -21,22 +30,8 @@ setuptools.setup(
         "Operating System :: OS Independent",
     ],
     python_requires='>=3.9',
-    install_requires=[
-        'flamapy-fw~=2.0.0.dev1',
-        'uvlparser~=2.0.1',
-        'afmparser~=1.0.3',
-    ],
+    install_requires=requirements,
     extras_require={
-        'dev': [
-            'pytest',
-            'pytest-mock',
-            'prospector',
-            'mypy',
-            'coverage',            
-            'antlr4-tools',
-        ]
+        'dev': dev_requirements
     },
-    dependency_links=[
-        'flamapy~=2.0.0.dev1',
-    ],
 )

flamapy-fm-2.0.0.dev1/flamapy_fm.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-flamapy~=2.0.0.dev1