flamapy-fm 2.0.0.dev8__tar.gz → 2.0.2.dev0__tar.gz

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/PKG-INFO

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

flamapy-fm-2.0.2.dev0/flamapy/metamodels/fm_metamodel/models/__init__.py

@@ -0,0 +1,23 @@
+from .feature_model import (
+    Feature,
+    Constraint,
+    FeatureModel,
+    Relation,
+    Domain,
+    Range,
+    Attribute,
+    Cardinality,
+    FeatureType
+)
+
+__all__ = [
+    'Attribute',
+    'Cardinality',
+    'Constraint',
+    'Domain',
+    'Feature',
+    'FeatureModel',
+    'FeatureType',
+    'Range',
+    'Relation',
+]

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/models/feature_model.py

@@ -1,8 +1,10 @@
 from typing import Any, Optional
 from functools import total_ordering
+from enum import Enum
 
 from flamapy.core.exceptions import FlamaException
 from flamapy.core.models import AST, VariabilityModel, VariabilityElement, ASTOperation
+from flamapy.core.models.ast import LOGICAL_OPERATORS, ARITHMETIC_OPERATORS, AGGREGATION_OPERATORS
 from flamapy.core.models.ast import simplify_formula, propagate_negation, to_cnf
 
 
@@ -68,6 +70,8 @@ class Relation:
         else:
             relation_type = "Other"
         res = f"({relation_type}) " + res
+        if res.endswith(" "):
+            res = res[:-1]
         return res
 
     def __hash__(self) -> int:
@@ -88,21 +92,39 @@ class Relation:
         return str(self) < str(other)
 
 
+class FeatureType(Enum):
+    BOOLEAN = 'Boolean'
+    INTEGER = 'Integer'
+    REAL = 'Real'
+    STRING = 'String'
+
+
+class Cardinality:
+
+    def __init__(self, card_min: int = 1, card_max: int = 1):
+        self.min = card_min
+        self.max = card_max
+
+
 @total_ordering
 class Feature(VariabilityElement):
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         name: str,
         relations: Optional[list["Relation"]] = None,
         parent: Optional["Feature"] = None,
         is_abstract: bool = False,
+        feature_type: FeatureType = FeatureType.BOOLEAN,
+        feature_cardinality: Cardinality = Cardinality(1, 1)
     ):
         super().__init__(name)
         self.name = name
         self.relations = [] if relations is None else relations
         self.parent = self._get_parent() if parent is None else parent
         self.is_abstract = is_abstract
+        self.feature_type = feature_type
+        self.feature_cardinality = feature_cardinality
         self.attributes = list["Attribute"]([])
 
     def is_empty(self) -> bool:
@@ -170,6 +192,19 @@ class Feature(VariabilityElement):
     def is_leaf(self) -> bool:
         return len(self.get_relations()) == 0
 
+    def is_boolean(self) -> bool:
+        return self.feature_type == FeatureType.BOOLEAN
+
+    def is_numerical(self) -> bool:
+        return self.feature_type in [FeatureType.INTEGER, FeatureType.REAL]
+
+    def is_string(self) -> bool:
+        return self.feature_type == FeatureType.STRING
+
+    def is_multifeature(self) -> bool:
+        """Return true if the feature has a cardinality different from [1..1]."""
+        return self.feature_cardinality.min != 1 or self.feature_cardinality.max != 1
+
     def __str__(self) -> str:
         return self.name
 
@@ -205,7 +240,11 @@ class Constraint:
         stack = [self.ast.root]
         while stack:
             node = stack.pop()
+            if node is None:
+                continue
             if node.is_unique_term():
+                if (isinstance(node.data, (int, float)) or node.data.startswith("'")):
+                    continue
                 features.add(node.data)
             elif node.is_unary_op():
                 stack.append(node.left)
@@ -214,6 +253,25 @@ class Constraint:
                 stack.append(node.left)
         return list(features)
 
+    def is_logical_constraint(self) -> bool:
+        """Return true if the constraint contains only logical operators."""
+        return all(op in LOGICAL_OPERATORS for op in self.ast.get_operators())
+
+    def is_arithmetic_constraint(self) -> bool:
+        """Return true if the constraint contains at least one arithmetic operator."""
+        return any(op in ARITHMETIC_OPERATORS for op in self.ast.get_operators())
+
+    def is_aggregation_constraint(self) -> bool:
+        """Return true if the constraint contains at least one aggregation operator."""
+        return any(op in AGGREGATION_OPERATORS for op in self.ast.get_operators())
+
+    def is_single_feature_constraint(self) -> bool:
+        """Return true if the constraint is a single feature or its negation."""
+        root_op = self._ast.root
+        return (root_op.is_term() or
+                (root_op.data == ASTOperation.NOT and
+                (root_op.left.is_term() or root_op.right.is_term())))
+
     def is_simple_constraint(self) -> bool:
         """Return true if the constraint is a simple constraint (requires or excludes)."""
         return self.is_requires_constraint() or self.is_excludes_constraint()
@@ -221,7 +279,7 @@ class Constraint:
     def is_complex_constraint(self) -> bool:
         """Return true if the constraint is a complex constraint
         (i.e., it is not a simple constraint)."""
-        return not self.is_simple_constraint()
+        return self.is_logical_constraint() and not self.is_simple_constraint()
 
     def is_requires_constraint(self) -> bool:
         """Return true if the constraint is a requires constraint."""
@@ -240,10 +298,10 @@ class Constraint:
                     and root_op.right.left.is_term()
                 )
                 return (
-                    neg_left
-                    and root_op.right.is_term()
-                    or neg_right
-                    and root_op.left.is_term()
+                    (neg_left
+                    and root_op.right.is_term())
+                    or (neg_right
+                    and root_op.left.is_term())
                 )
         return False
 
@@ -276,6 +334,8 @@ class Constraint:
     def is_pseudocomplex_constraint(self) -> bool:
         """Return true if the constraint is a pseudo-complex constraint
         (i.e., it can be transformed to a set of simple constraints)."""
+        if not self.is_logical_constraint():
+            return False
         split_ctcs = split_constraint(self)
         return len(split_ctcs) > 1 and all(
             ctc.is_simple_constraint() for ctc in split_ctcs
@@ -284,11 +344,13 @@ class Constraint:
     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)."""
+        if not self.is_logical_constraint():
+            return False
         split_ctcs = split_constraint(self)
         return any(ctc.is_complex_constraint() for ctc in split_ctcs)
 
     def __str__(self) -> str:
-        return f"({self.name}) {str(self.ast)}"
+        return f"({self.name}) {self.ast!s}"
 
     def __hash__(self) -> int:
         return hash(str(self.ast).lower())
@@ -334,6 +396,15 @@ class FeatureModel(VariabilityModel):
                 features.extend(relation.children)
         return features
 
+    def get_boolean_features(self) -> list["Feature"]:
+        return [f for f in self.get_features() if f.is_boolean()]
+
+    def get_numerical_features(self) -> list["Feature"]:
+        return [f for f in self.get_features() if f.is_numerical()]
+
+    def get_string_features(self) -> list["Feature"]:
+        return [f for f in self.get_features() if f.is_string()]
+
     def get_constraints(self) -> list["Constraint"]:
         return self.ctcs
 
@@ -352,6 +423,15 @@ class FeatureModel(VariabilityModel):
     def get_feature_by_name(self, feature_name: str) -> Optional["Feature"]:
         return next((f for f in self.get_features() if f.name == feature_name), None)
 
+    def get_logical_constraints(self) -> list["Constraint"]:
+        return [c for c in self.get_constraints() if c.is_logical_constraint()]
+
+    def get_arithmetic_constraints(self) -> list["Constraint"]:
+        return [c for c in self.get_constraints() if c.is_arithmetic_constraint()]
+
+    def get_aggregations_constraints(self) -> list["Constraint"]:
+        return [c for c in self.get_constraints() if c.is_aggregation_constraint()]
+
     def get_complex_constraints(self) -> list["Constraint"]:
         return [c for c in self.get_constraints() if c.is_complex_constraint()]
 

flamapy-fm-2.0.2.dev0/flamapy/metamodels/fm_metamodel/operations/__init__.py

@@ -0,0 +1,26 @@
+from .fm_core_features import FMCoreFeatures
+from .fm_count_leafs import FMCountLeafs
+from .fm_leaf_features import FMLeafFeatures
+from .fm_average_branching_factor import FMAverageBranchingFactor
+from .fm_feature_ancestors import FMFeatureAncestors
+from .fm_max_depth_tree import FMMaxDepthTree
+from .fm_estimated_configurations_number import FMEstimatedConfigurationsNumber
+from .fm_atomic_sets import FMAtomicSets
+from .fm_metrics import FMMetrics
+from .fm_generate_random_attribute import GenerateRandomAttribute
+from .fm_variation_points import FMVariationPoints
+
+
+__all__ = [
+           'FMAtomicSets',
+           'FMAverageBranchingFactor',
+           'FMCoreFeatures',
+           'FMCountLeafs',
+           'FMEstimatedConfigurationsNumber',
+           'FMFeatureAncestors',
+           'FMLeafFeatures',
+           'FMMaxDepthTree',
+           'FMMetrics',
+           'FMVariationPoints',
+           'GenerateRandomAttribute',
+]

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/operations/fm_generate_random_attribute.py

@@ -5,9 +5,9 @@ from flamapy.core.models import VariabilityModel
 from flamapy.core.operations import Operation
 from flamapy.core.exceptions import FlamaException
 from flamapy.metamodels.fm_metamodel.models import (
-    FeatureModel, 
+    FeatureModel,
     Range,
-    Domain, 
+    Domain,
     Attribute
 )
 
@@ -44,19 +44,19 @@ class GenerateRandomAttribute(Operation):
         if self._attribute_domain is None:
             raise FlamaException("Attribute's domain has not been provided.")
         fm_model = cast(FeatureModel, model)
-        self.result = generate_random_attribute_values(fm_model, 
-                                                       self._attribute_name, 
+        self.result = generate_random_attribute_values(fm_model,
+                                                       self._attribute_name,
                                                        self._attribute_domain,
                                                        self._only_leaf_features)
         return self
 
 
-def generate_random_attribute_values(feature_model: FeatureModel, 
+def generate_random_attribute_values(feature_model: FeatureModel,
                                      name: str,
                                      domain: Domain,
                                      only_leaf_features: bool) -> FeatureModel:
     for feature in feature_model.get_features():
-        if not only_leaf_features or only_leaf_features and feature.is_leaf():
+        if not only_leaf_features or (only_leaf_features and feature.is_leaf()):
             if not any(name == attr.name for attr in feature.get_attributes()):
                 random_value = get_random_value_from_domain(domain)
                 new_attribute = Attribute(name, domain, random_value)

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/operations/fm_metrics.py

@@ -5,7 +5,7 @@ from flamapy.core.exceptions import FlamaException
 from flamapy.core.models.variability_model import VariabilityModel
 from flamapy.core.operations.metrics_operation import Metrics
 from flamapy.metamodels.fm_metamodel.models import FeatureModel, Feature
-from flamapy.metamodels.fm_metamodel import operations as fm_operations
+from flamapy.metamodels.fm_metamodel.operations import FMAverageBranchingFactor
 
 
 def metric_method(func: Callable[..., dict[str, Any]]) -> Callable[..., dict[str, Any]]:
@@ -30,7 +30,7 @@ class FMMetrics(Metrics):  # pylint: disable=too-many-instance-attributes
         super().__init__()
         self.model: Optional[FeatureModel] = None
         self.result: list[dict[str, Any]] = []
-        self.model_type_extension = "fm"
+        self._model_type_extension = "fm"
         self._features: list[Feature] = []
         self._features_by_name: dict[str, Feature] = {}
         self._abstract_features: dict[str, Feature] = {}
@@ -39,6 +39,14 @@ class FMMetrics(Metrics):  # pylint: disable=too-many-instance-attributes
         self._constraints_per_features: list[int] = []
         self._feature_ancestors: list[int] = []
 
+    @property
+    def model_type_extension(self) -> str:
+        return self._model_type_extension
+
+    @model_type_extension.setter
+    def model_type_extension(self, ext: str) -> None:
+        self._model_type_extension = ext
+
     def get_result(self) -> list[dict[str, Any]]:
         return self.result
 
@@ -516,7 +524,7 @@ class FMMetrics(Metrics):  # pylint: disable=too-many-instance-attributes
             raise FlamaException("Feature model is not defined.")
 
         name = "Branching factor"
-        _avg_branching_factor = fm_operations.average_branching_factor(self.model)
+        _avg_branching_factor = FMAverageBranchingFactor().execute(self.model).get_result()
         result = self.construct_result(
             name=name, doc=self.branching_factor.__doc__, result=_avg_branching_factor
         )

flamapy-fm-2.0.2.dev0/flamapy/metamodels/fm_metamodel/operations/fm_variation_points.py

@@ -0,0 +1,37 @@
+from typing import cast
+
+from flamapy.core.models import VariabilityModel
+from flamapy.metamodels.fm_metamodel.operations.interfaces import VariationPoints
+from flamapy.metamodels.fm_metamodel.models import FeatureModel, Feature
+
+
+class FMVariationPoints(VariationPoints):
+
+    def __init__(self) -> None:
+        self.result: dict[Feature, list[Feature]] = {}
+
+    def get_result(self) -> dict[Feature, list[Feature]]:
+        return self.result
+
+    def execute(self, model: VariabilityModel) -> 'FMVariationPoints':
+        fm_model = cast(FeatureModel, model)
+        self.result = variation_points(fm_model)
+        return self
+
+    def variation_points(self) -> dict[Feature, list[Feature]]:
+        return self.get_result()
+
+
+def variation_points(feature_model: FeatureModel) -> dict[Feature, list[Feature]]:
+    vps: dict[Feature, list[Feature]] = {}
+    features = [feature_model.root]
+    while features:
+        feature = features.pop()
+        variants = []
+        for relation in feature.get_relations():
+            if not relation.is_mandatory():
+                variants.extend(relation.children)
+        if variants:
+            vps[feature] = variants
+        features.extend(feature.get_children())
+    return vps

flamapy-fm-2.0.2.dev0/flamapy/metamodels/fm_metamodel/operations/interfaces/__init__.py

@@ -0,0 +1,4 @@
+from .variation_points import VariationPoints
+
+
+__all__ = ['VariationPoints']

flamapy-fm-2.0.2.dev0/flamapy/metamodels/fm_metamodel/operations/interfaces/variation_points.py

@@ -0,0 +1,21 @@
+from abc import abstractmethod
+
+from flamapy.core.operations import Operation
+
+from flamapy.metamodels.fm_metamodel.models import Feature
+
+
+class VariationPoints(Operation):
+    """The variation points of a feature model are those features that require to make a choice
+    (i.e., select a variant).
+
+    This operation returns the variation points and the variants of each variation point.
+    """
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def variation_points(self) -> dict[Feature, list[Feature]]:
+        pass

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/transformations/__init__.py

@@ -13,16 +13,18 @@ from .glencoe_writer import GlencoeWriter
 from .clafer_writer import ClaferWriter
 
 
-__all__ = ['AFMReader',
+__all__ = [
+           'AFMReader',
            'AFMWriter',
+           'ClaferWriter',
            'FeatureIDEReader',
            'FeatureIDEWriter',
-           'JSONWriter',
+           'GlencoeReader',
+           'GlencoeWriter',
            'JSONReader',
+           'JSONWriter',
            'SPLOTWriter',
            'UVLReader',
            'UVLWriter',
            'XMLReader',
-           'GlencoeReader',
-           'GlencoeWriter',
-           'ClaferWriter']
+]

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/transformations/afm_reader.py

@@ -128,6 +128,8 @@ class AFMReader(TextToModel):
         if attribute_feature is None:
             raise FlamaException("attribute_feature is not defined")
 
+        domain = None  # type: Optional[Domain]
+
         discrete_domain_node = attribute_spec.attribute_domain().discrete_domain_spec()
         if discrete_domain_node is not None:
             values = []
@@ -179,6 +181,8 @@ class AFMReader(TextToModel):
     def build_ast_node(
         self, expression: AFMParser.ExpressionContext, prefix: str
     ) -> Node:
+        var_name = None  # Ensure var_name is initialized
+
         if isinstance(expression, AFMParser.AtomContext):
             if expression.variable() is not None:
                 var_name = prefix + expression.variable().getText()

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/transformations/clafer_writer.py

@@ -1,4 +1,5 @@
 import re
+import string
 from enum import Enum
 from typing import Any, Optional
 
@@ -128,8 +129,8 @@ def serialize_constraint(ctc: Constraint) -> str:
 
 
 def attributes_definition(feature_model: FeatureModel) -> str:
-    attributes = {attribute.get_name(): parse_type_value(attribute.get_default_value()) 
-                  for feature in feature_model.get_features() 
+    attributes = {attribute.get_name(): parse_type_value(attribute.get_default_value())
+                  for feature in feature_model.get_features()
                   for attribute in feature.get_attributes()}
     result = ''
     if attributes:
@@ -152,4 +153,8 @@ def parse_type_value(value: Any) -> str:
 
 
 def safename(name: str) -> str:
-    return f'"{name}"' if ' ' in name else name
+    return f'"{name}"' if any(char not in safecharacters() for char in name) else name
+
+
+def safecharacters() -> str:
+    return string.ascii_letters + string.digits + '_'

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/transformations/featureide_writer.py

@@ -1,7 +1,8 @@
+import string
 from xml.etree import ElementTree
 from xml.etree.ElementTree import Element
 from xml.dom import minidom
-from typing import Any 
+from typing import Any
 
 from flamapy.core.models.ast import Node, ASTOperation
 from flamapy.core.transformations import ModelToText
@@ -31,9 +32,9 @@ class FeatureIDEWriter(ModelToText):
 
     def transform(self) -> str:
         fm_tree = _to_featureidexml(self._source_model).getroot()
-        xml_str = ElementTree.tostring(fm_tree, 
-                                       encoding='UTF-8', 
-                                       method='xml', 
+        xml_str = ElementTree.tostring(fm_tree,
+                                       encoding='UTF-8',
+                                       method='xml',
                                        xml_declaration=True)
         xml_str = prettify(xml_str)
         if self._path is not None:
@@ -47,8 +48,8 @@ def _to_featureidexml(feature_model: FeatureModel) -> ElementTree.ElementTree:
     tree = ElementTree.ElementTree(fm_element)
     struct = ElementTree.SubElement(fm_element, FeatureIDEReader.TAG_STRUCT)
     constraints = ElementTree.SubElement(fm_element, FeatureIDEReader.TAG_CONSTRAINTS)
-    root = ElementTree.SubElement(struct, 
-                                  _tag_element(feature_model.root), 
+    root = ElementTree.SubElement(struct,
+                                  _tag_element(feature_model.root),
                                   _get_attributes(feature_model.root))
     _create_tree(root, feature_model.root.get_relations())
     _get_constraints(constraints, feature_model.get_constraints())
@@ -66,24 +67,23 @@ def _create_tree(parent_element: Element, relations: list[Relation]) -> None:
 
 def _get_attributes(feature: Feature) -> dict[str, str]:
     atributes = {}
-    if feature.is_mandatory(): 
+    if feature.is_mandatory():
         atributes['mandatory'] = 'true'
-    if feature.is_abstract: 
+    if feature.is_abstract:
         atributes['abstract'] = 'true'
     atributes['name'] = safename(feature.name)
     return atributes
 
 
 def _tag_element(feature: Feature) -> str:
-    if feature.is_leaf(): 
+    if feature.is_leaf():
         name = FeatureIDEReader.TAG_FEATURE
-    else: 
-        if feature.is_or_group(): 
-            name = FeatureIDEReader.TAG_OR
-        elif feature.is_alternative_group(): 
-            name = FeatureIDEReader.TAG_ALT
-        else: 
-            name = FeatureIDEReader.TAG_AND
+    elif feature.is_or_group():
+        name = FeatureIDEReader.TAG_OR
+    elif feature.is_alternative_group():
+        name = FeatureIDEReader.TAG_ALT
+    else:
+        name = FeatureIDEReader.TAG_AND
     return name
 
 
@@ -139,4 +139,8 @@ def prettify(xml: str) -> bytes:
 
 
 def safename(name: str) -> str:
-    return f'"{name}"' if ' ' in name else name
+    return f'"{name}"' if any(char not in safecharacters() for char in name) else name
+
+
+def safecharacters() -> str:
+    return string.ascii_letters + string.digits + '_'

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/transformations/glencoe_writer.py

@@ -1,4 +1,5 @@
 import json
+import string
 from typing import Any
 
 from flamapy.core.models.ast import Node, ASTOperation
@@ -106,4 +107,8 @@ def _get_ctc_info(ast_node: Node) -> dict[str, Any]:
 
 
 def safename(name: str) -> str:
-    return f'"{name}"' if ' ' in name else name
+    return f'"{name}"' if any(char not in safecharacters() for char in name) else name
+
+
+def safecharacters() -> str:
+    return string.ascii_letters + string.digits + '_'

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/transformations/json_reader.py

@@ -7,10 +7,10 @@ from flamapy.core.exceptions import ParsingException
 from flamapy.core.transformations import TextToModel
 
 from flamapy.metamodels.fm_metamodel.models import (
-    FeatureModel, 
-    Relation, 
-    Feature, 
-    Constraint, 
+    FeatureModel,
+    Relation,
+    Feature,
+    Constraint,
     Attribute
 )
 
@@ -64,8 +64,7 @@ def parse_attributes(feature: Feature, feature_node: Dict[str, Any]) -> 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:  # noqa: C901
     if 'relations' in feature_node:
         for relation in feature_node['relations']:
             children = []
@@ -73,6 +72,7 @@ def parse_relations(feature: Feature, feature_node: Dict[str, Any]) -> None:
                 child_feature = parse_tree(feature, child)
                 children.append(child_feature)
             relation_type = relation['type']
+            new_relation: Optional[Relation] = None
             if relation_type == JSONFeatureType.OPTIONAL.value:
                 new_relation = Relation(feature, children, 0, 1)
             elif relation_type == JSONFeatureType.MANDATORY.value:
@@ -87,7 +87,10 @@ def parse_relations(feature: Feature, feature_node: Dict[str, Any]) -> None:
                 card_min = relation['card_min']
                 card_max = relation['card_max']
                 new_relation = Relation(feature, children, card_min, card_max)
-            feature.add_relation(new_relation)
+            if new_relation is not None:
+                feature.add_relation(new_relation)
+            else:
+                raise ParsingException(f'Invalid relation in JSON: {relation}')
 
 
 def parse_constraints(constraints_info: List[Dict[str, Any]]) -> List[Constraint]:
@@ -129,13 +132,13 @@ def parse_ast_constraint(ctc_info: Dict[str, Any]) -> Node:
         node = Node(ASTOperation.EQUIVALENCE, left, right)
     elif ctc_type == ASTOperation.AND.value:
         op_list = [parse_ast_constraint(op) for op in ctc_operands]
-        node = functools.reduce(lambda l, r: Node(ASTOperation.AND, l, r), op_list)
+        node = functools.reduce(lambda lambd, r: Node(ASTOperation.AND, lambd, r), op_list)
     elif ctc_type == ASTOperation.OR.value:
         op_list = [parse_ast_constraint(op) for op in ctc_operands]
-        node = functools.reduce(lambda l, r: Node(ASTOperation.OR, l, r), op_list)
+        node = functools.reduce(lambda lambd, r: Node(ASTOperation.OR, lambd, r), op_list)
     elif ctc_type == ASTOperation.XOR.value:
         op_list = [parse_ast_constraint(op) for op in ctc_operands]
-        node = functools.reduce(lambda l, r: Node(ASTOperation.XOR, l, r), op_list)
+        node = functools.reduce(lambda lambd, r: Node(ASTOperation.XOR, lambd, r), op_list)
     else:
         raise ParsingException(f'Invalid constraint in JSON: {ctc_info}')
-    return node
+    return node

{flamapy-fm-2.0.0.dev8 → flamapy-fm-2.0.2.dev0}/flamapy/metamodels/fm_metamodel/transformations/json_writer.py

@@ -1,4 +1,5 @@
 import json
+import string
 from enum import Enum
 from typing import Any, Dict, List
 
@@ -126,4 +127,8 @@ def get_ctc_info(ast_node: Node) -> Dict[str, Any]:
 
 
 def safename(name: str) -> str:
-    return f'"{name}"' if ' ' in name else name
+    return f'"{name}"' if any(char not in safecharacters() for char in name) else name
+
+
+def safecharacters() -> str:
+    return string.ascii_letters + string.digits + '_'