flamapy-fm 2.1.0.dev0__tar.gz → 2.1.0.dev2__tar.gz

flamapy_fm-2.1.0.dev2/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

flamapy_fm-2.1.0.dev2/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: flamapy-fm
+Version: 2.1.0.dev2
+Summary: flamapy-fm is a plugin to Flamapy module
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/fm_metamodel
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: flamapy-fw~=2.1.0.dev2
+Requires-Dist: uvlparser~=2.0.1.dev61
+Requires-Dist: afmparser~=1.0.3
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: prospector; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: antlr4-tools; extra == "dev"
+Dynamic: license-file
+
+# fm_metamodel
+
+This repo host the feature model concrete classes
+
+
+## Install for development
+
+```
+pip install -e .
+```

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy/metamodels/fm_metamodel/models/__init__.py

@@ -7,11 +7,13 @@ from .feature_model import (
     Range,
     Attribute,
     Cardinality,
-    FeatureType
+    FeatureType,
+    AttributeType
 )
 
 __all__ = [
     'Attribute',
+    'AttributeType',
     'Cardinality',
     'Constraint',
     'Domain',
@@ -19,5 +21,5 @@ __all__ = [
     'FeatureModel',
     'FeatureType',
     'Range',
-    'Relation',
+    'Relation'
 ]

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy/metamodels/fm_metamodel/models/feature_model.py

@@ -99,6 +99,15 @@ class FeatureType(Enum):
     STRING = 'String'
 
 
+class AttributeType(Enum):
+    BOOLEAN = 'Boolean'
+    INTEGER = 'Integer'
+    REAL = 'Real'
+    STRING = 'String'
+    VECTOR = 'Vector'  # Vector (list of values)
+    NESTED = 'Nested'  # Nested attribute (i.e., list of attributes)
+
+
 class Cardinality:
 
     def __init__(self, card_min: int = 1, card_max: int = 1):
@@ -401,6 +410,20 @@ class FeatureModel(VariabilityModel):
                 features.extend(relation.children)
         return features
 
+    def get_attributes(self) -> list["Attribute"]:
+        attributes_dict: dict[str, "Attribute"] = {}
+        for feature in self.get_features():
+            attributes_dict.update({attr.name: attr for attr in feature.get_attributes()})
+        attributes = []
+        for attr in attributes_dict.values():
+            attribute = Attribute(attr.name, attr.domain, None, attr.null_value)
+            attribute.attribute_type = attr.attribute_type
+            attributes.append(attribute)
+        return attributes
+
+    def get_attribute_by_name(self, attribute_name: str) -> Optional["Attribute"]:
+        return next((a for a in self.get_attributes() if a.name == attribute_name), None)
+
     def get_boolean_features(self) -> list["Feature"]:
         return [f for f in self.get_features() if f.is_boolean()]
 
@@ -468,14 +491,23 @@ class FeatureModel(VariabilityModel):
         res += "Relations:\r\n"
         for i, relation in enumerate(self.get_relations()):
             res += f"R{i}: {relation}\r\n"
+        res += "Constraints:\r\n"
         for i, ctc in enumerate(self.ctcs):
             res += f"CTC{i}: {ctc}\r\n"
-        attributes_res = ""
+        res += "Attributes:\r\n"
+        attr_counter = 0
         for feature in self.get_features():
             for attribute in feature.get_attributes():
-                attributes_res += f"{attribute}" + "\r\n"
-        if attributes_res != "":
-            res += "Attributes:\r\n" + attributes_res
+                res += f"ATTR{attr_counter}: {attribute}" + "\r\n"
+                attr_counter += 1
+        res += "Imports:\r\n"
+        for i, (name, imp) in enumerate(self.imports.items()):
+            alias = next((alias for alias, namespace in self.alias_namespace.items()
+                          if namespace == name), None)
+            if alias is None:
+                res += f"IMP{i}: {name} -> {imp}\r\n"
+            else:
+                res += f"IMP{i}: {name} ({alias}) -> {imp}\r\n"
         return res
 
     def __hash__(self) -> int:
@@ -560,6 +592,22 @@ class Attribute:
         self.domain: Optional["Domain"] = domain
         self.default_value: "Any" = default_value
         self.null_value: Optional[Any] = null_value
+        self.attribute_type: Optional["AttributeType"] = self._infer_attribute_type(default_value)
+
+    def _infer_attribute_type(self, value: Any) -> Optional["AttributeType"]:
+        if isinstance(value, bool):
+            attr_type = AttributeType.BOOLEAN
+        elif isinstance(value, int):
+            attr_type = AttributeType.INTEGER
+        elif isinstance(value, float):
+            attr_type = AttributeType.REAL
+        elif isinstance(value, str):
+            attr_type = AttributeType.STRING
+        elif isinstance(value, list):
+            attr_type = AttributeType.VECTOR
+        else:
+            attr_type = AttributeType.NESTED
+        return attr_type
 
     def get_name(self) -> str:
         return self.name
@@ -601,7 +649,11 @@ class Attribute:
         if self.domain is not None:
             result = result + "Domain: " + str(self.domain)
         if self.default_value is not None:
-            result = result + "Default value: " + str(self.default_value)
+            if isinstance(self.default_value, list):
+                default_value_str = '[' + ', '.join(str(v) for v in self.default_value) + ']'
+            else:
+                default_value_str = str(self.default_value)
+            result = result + "Default value: " + default_value_str
         if self.null_value is not None:
             result = result + "Null value: " + str(self.null_value)
 

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy/metamodels/fm_metamodel/transformations/flat_fm.py

@@ -39,6 +39,11 @@ class FlatFM(ModelToModel):
                 # Copy the feature's attributes and relations from the referenced feature
                 feature.relations = feature.reference.relations
                 feature.attributes.extend(feature.reference.attributes)
+                # Process attribute constraints
+                feature.constraints_attributes.extend(feature.reference.constraints_attributes)
+                process_attribute_constraints(feature.reference,
+                                              new_feature_model.alias_namespace,
+                                              self._maintain_namespaces)
                 if not self._maintain_namespaces:
                     feature.name = feature.reference.name
                 else:
@@ -46,6 +51,9 @@ class FlatFM(ModelToModel):
                     put_namespace_to_features(feature.reference, namespace)
                 feature.reference = None  # Clear reference after copying
             features.extend(feature.get_children())
+        # Add contraints from imported models
+        for imported_fm in self.feature_model.imports.values():
+            new_feature_model.ctcs.extend(imported_fm.ctcs)
         if not self._maintain_namespaces:
             for ctcs in new_feature_model.ctcs:
                 process_namespace_constraint(ctcs.ast, new_feature_model.alias_namespace)
@@ -63,6 +71,20 @@ def put_namespace_to_features(root: Feature, namespace: str) -> None:
         features.extend(feature.get_children())
 
 
+def process_attribute_constraints(root: Feature,
+                                  alias_namespace: dict[str, str],
+                                  maintain_namespaces: bool) -> None:
+    """Put the namespace to the constraints of the attributes constraints and return them to
+    incorporate in the new feature model."""
+    features = [root]
+    while features:
+        feature = features.pop()
+        for ctc in feature.constraints_attributes:
+            if not maintain_namespaces:
+                process_namespace_constraint(ctc.ast, alias_namespace)
+        features.extend(feature.get_children())
+
+
 def process_namespace_constraint(ast: AST, alias_namespace: dict[str, str]) -> None:
     """Replace the namespace of the features in the constraints."""
     stack = [ast.root]

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy/metamodels/fm_metamodel/transformations/glencoe_writer.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import string
 from typing import Any
 
@@ -6,6 +7,8 @@ from flamapy.core.models.ast import Node, ASTOperation
 from flamapy.core.transformations import ModelToText
 from flamapy.metamodels.fm_metamodel.models import FeatureModel, Feature, Constraint
 
+logger = logging.getLogger(__name__)
+
 
 class GlencoeWriter(ModelToText):
     CTC_TYPES = {
@@ -38,8 +41,8 @@ class GlencoeWriter(ModelToText):
 
 def _to_json(feature_model: FeatureModel) -> dict[str, Any]:
     result: dict[str, Any] = {}
-    print(f'-{feature_model.root.name}-')
-    print(f'-{safename(feature_model.root.name)}-')
+    logger.debug("Root name: %s", feature_model.root.name)
+    logger.debug("Safe root name: %s", safename(feature_model.root.name))
     result["id"] = f"FM_{safename(feature_model.root.name)}"
     result["name"] = f"FM_{safename(feature_model.root.name)}"
     result["features"] = _get_features_info(feature_model.get_features())

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy/metamodels/fm_metamodel/transformations/refactorings/feature_cardinality_refactoring.py

@@ -1,4 +1,5 @@
 import copy
+import logging
 from dataclasses import dataclass
 from typing import Any, cast
 
@@ -16,6 +17,8 @@ from flamapy.metamodels.fm_metamodel.transformations.refactorings import (
     RefactoringException
 )
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class CloneContext:
@@ -167,7 +170,8 @@ def contextualize_constraint(feature_model: FeatureModel,
                              features_names_map: dict[str, str]) -> Constraint:
     """Create a contextualized constraint for the given constraints according to the provided
     feature clone."""
-    print(f'Contextualizing constraint {constraint.name} for features {features_names_map}')
+    logger.debug("Contextualizing constraint %s for features %s",
+                 constraint.name, features_names_map)
     # Create a copy of the constraint
     new_constraint = copy.deepcopy(constraint)
     # Rename the constraint's name

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy/metamodels/fm_metamodel/transformations/uvl_reader.py

@@ -46,7 +46,7 @@ class UVLReader(TextToModel):
 
     def __init__(self, path: str) -> None:
         self.path: str = os.sep.join(path.split(os.sep)[:-1])
-        self.file: str = path.split(os.sep)[-1]
+        self.file: str = path.rsplit(os.sep, maxsplit=1)[-1]
         self.namespace: str = ""
         self.parse_tree: Any = None
         self.model: Optional[FeatureModel] = None
@@ -182,9 +182,41 @@ class UVLReader(TextToModel):
                 if key == "abstract" and (value is None or value):
                     feature.is_abstract = True
                 else:
-                    feature.add_attribute(Attribute(name=str(key), default_value=value))
+                    # Handle attributes
+                    if value is None:  # for boolean values the value may be not provided
+                        default_value = True
+                    elif isinstance(value, dict):  # it represents nested attributes
+                        attributes_list = self._process_nested_attribute(feature, str(key), value)
+                        for attr in attributes_list:
+                            feature.add_attribute(attr)
+                        default_value = None
+                    else:
+                        default_value = value
+                    feature.add_attribute(Attribute(name=str(key), default_value=default_value))
         feature.constraints_attributes = self.constraints_attributes[feature]
 
+    def _process_nested_attribute(self,
+                                  parent: Feature,
+                                  parent_attribute_name: str,
+                                  nested_values: dict[Any, Any]) -> list[Attribute]:
+        attributes = []
+        for key, value in nested_values.items():
+            if value is None:  # for boolean values the value may be not provided
+                default_value = True
+            elif isinstance(value, dict):
+                attributes_list = self._process_nested_attribute(parent,
+                                                                 f'{parent_attribute_name}.{key}',
+                                                                 value)
+                for attr in attributes_list:
+                    attributes.append(attr)
+                    default_value = None
+            else:
+                default_value = value
+            attribute = Attribute(name=f'{parent_attribute_name}.{key}',
+                                  default_value=default_value)
+            attribute.parent = parent
+            attributes.append(attribute)
+        return attributes
 
     def _process_imported_feature(self, feature: Feature) -> None:
         feature_reference = feature.name.split('.')
@@ -272,214 +304,130 @@ class UVLReader(TextToModel):
             list_features.append(feature)
         return list_features
 
-    def process_constraints(
-        self, constraint_node: UVLPythonParser.ConstraintContext
-    ) -> Node:
-        process = self.process_literal_constraint(constraint_node)
-        if process is None:
-            process = self.process_logical_constraint(constraint_node)
-        if process is None:
-            process = self.process_arithmetic_constraint(constraint_node)
-        if process is None:
-            if isinstance(constraint_node, UVLPythonParser.EquationConstraintContext):
-                process = self.process_equation_constraint(constraint_node)
-            elif isinstance(constraint_node, UVLPythonParser.ParenthesisConstraintContext):
-                process = self.process_parenthesis_constraint(constraint_node)
-            elif isinstance(constraint_node, UVLPythonParser.BracketExpressionContext):
-                process = self.process_bracket_expression_constraint(constraint_node)
-            elif isinstance(constraint_node, UVLPythonParser.AggregateFunctionExpressionContext):
-                process = self.process_aggregate_function_constraint(constraint_node)
-        if process is None:  # Handle unexpected constraint types
-            raise NotImplementedError(
-                f"Constraint of type {type(constraint_node)} not handled"
-            )
-        return process
-
-    def process_aggregate_function_constraint(
-        self, aggregate_function_context: UVLPythonParser.AggregateFunctionExpressionContext
-    ) -> Node:
-        """Process an aggregate function constraint."""
-        aggregation = aggregate_function_context.aggregateFunction()
-        if isinstance(aggregation, UVLPythonParser.StringAggregateFunctionExpressionContext):
-            string_function = aggregation.stringAggregateFunction()
-            if isinstance(string_function, UVLPythonParser.LengthAggregateFunctionContext):
-                literal = string_function.reference()
-                return Node(ASTOperation.LEN, Node(literal.getText().replace('"', '')))
-            raise NotImplementedError(f"String function {type(string_function)} not handled.")
-        if isinstance(aggregation, UVLPythonParser.NumericAggregateFunctionExpressionContext):
-            numeric_function = aggregation.numericAggregateFunction()
-            if isinstance(numeric_function, UVLPythonParser.FloorAggregateFunctionContext):
-                literal = numeric_function.reference()
-                return Node(ASTOperation.FLOOR, Node(literal.getText().replace('"', '')))
-            if isinstance(numeric_function, UVLPythonParser.CeilAggregateFunctionContext):
-                literal = numeric_function.reference()
-                return Node(ASTOperation.CEIL, Node(literal.getText().replace('"', '')))
-            raise NotImplementedError(f"Numeric function {type(numeric_function)} not handled.")
-        if isinstance(aggregation, UVLPythonParser.AvgAggregateFunctionContext):
-            literals = aggregation.reference()
-            attribute_literal = literals[0].getText().replace('"', '')
-            if len(literals) > 1:
-                feature_literal = literals[1].getText().replace('"', '')
-                node = Node(ASTOperation.AVG, Node(attribute_literal), Node(feature_literal))
-            else:
-                node = Node(ASTOperation.AVG, Node(attribute_literal))
-            return node
-        if isinstance(aggregation, UVLPythonParser.SumAggregateFunctionContext):
-            literals = aggregation.reference()
-            attribute_literal = literals[0].getText().replace('"', '')
-            if len(literals) > 1:
-                feature_literal = literals[1].getText().replace('"', '')
-                node = Node(ASTOperation.SUM, Node(attribute_literal), Node(feature_literal))
-            else:
-                node = Node(ASTOperation.SUM, Node(attribute_literal))
-            return node
-        raise NotImplementedError(f"Aggregate function {type(aggregation)} not handled.")
-
-    def process_literal_constraint(self, ctc_node: UVLPythonParser.ConstraintContext) -> Node:
-        """Process a literal constraint."""
-        process = None
-        if isinstance(ctc_node,
-                      (UVLPythonParser.LiteralConstraintContext,
-                       UVLPythonParser.LiteralExpressionContext)):
-            process = self.process_literal(ctc_node)
-        elif isinstance(ctc_node, UVLPythonParser.IntegerLiteralExpressionContext):
-            process = self.process_integer_literal_constraint(ctc_node)
-        elif isinstance(ctc_node, UVLPythonParser.FloatLiteralExpressionContext):
-            process = self.process_float_literal_constraint(ctc_node)
-        elif isinstance(ctc_node, UVLPythonParser.StringLiteralExpressionContext):
-            process = self.process_string_literal_constraint(ctc_node)
-        return process
-
-    def process_logical_constraint(self, ctc_node: UVLPythonParser.ConstraintContext) -> Node:
-        """Process a logical constraint."""
-        process = None
-        operator = None
-        if isinstance(ctc_node, UVLPythonParser.NotConstraintContext):
-            operator = ASTOperation.NOT
-            process = self.process_unary_constraint(ctc_node, operator)
-        elif isinstance(ctc_node, UVLPythonParser.AndConstraintContext):
-            operator = ASTOperation.AND
-        elif isinstance(ctc_node, UVLPythonParser.OrConstraintContext):
-            operator = ASTOperation.OR
-        elif isinstance(ctc_node, UVLPythonParser.ImplicationConstraintContext):
-            operator = ASTOperation.IMPLIES
-        elif isinstance(ctc_node, UVLPythonParser.EquivalenceConstraintContext):
-            operator = ASTOperation.EQUIVALENCE
-        if operator is None:  # It is other type of constraint
-            return None
-        if process is None:  # It is a binary constraint
-            return self.process_binary_constraints(ctc_node, operator)
-        return process
-
-    def process_arithmetic_constraint(self, ctc_node: UVLPythonParser.ConstraintContext) -> Node:
-        """Process an arithmetic constraint."""
-        operator = None
-        if isinstance(ctc_node, UVLPythonParser.AddExpressionContext):
-            operator = ASTOperation.ADD
-        elif isinstance(ctc_node, UVLPythonParser.SubExpressionContext):
-            operator = ASTOperation.SUB
-        elif isinstance(ctc_node, UVLPythonParser.DivExpressionContext):
-            operator = ASTOperation.DIV
-        elif isinstance(ctc_node, UVLPythonParser.MulExpressionContext):
-            operator = ASTOperation.MUL
-        if operator is None:  # It is other type of constraint
-            return None
-        return self.process_binary_expression(ctc_node, operator)
-
-    def process_equation_constraint(
-        self, equation_context: UVLPythonParser.EquationConstraintContext
-    ) -> Node:
-        """Process an equation constraint."""
-        equation = equation_context.equation()
-        operator = None
-        if isinstance(equation, UVLPythonParser.EqualEquationContext):
-            operator = ASTOperation.EQUALS
-        elif isinstance(equation, UVLPythonParser.LowerEquationContext):
-            operator = ASTOperation.LOWER
-        elif isinstance(equation, UVLPythonParser.LowerEqualsEquationContext):
-            operator = ASTOperation.LOWER_EQUALS
-        elif isinstance(equation, UVLPythonParser.GreaterEquationContext):
-            operator = ASTOperation.GREATER
-        elif isinstance(equation, UVLPythonParser.GreaterEqualsEquationContext):
-            operator = ASTOperation.GREATER_EQUALS
-        elif isinstance(equation, UVLPythonParser.NotEqualsEquationContext):
-            operator = ASTOperation.NOT_EQUALS
-        else:
-            raise NotImplementedError(f"Expression of type {type(equation)} not handled.")
-        return self.process_binary_expression(equation, operator)
-
-    def process_integer_literal_constraint(
-        self, literal_context: UVLPythonParser.IntegerLiteralExpressionContext
-    ) -> Node:
-        """Process an integer literal expression."""
-        return Node(int(literal_context.getText()))
-
-    def process_float_literal_constraint(
-        self, literal_context: UVLPythonParser.IntegerLiteralExpressionContext
-    ) -> Node:
-        """Process a float literal expression."""
-        return Node(float(literal_context.getText()))
-
-    def process_string_literal_constraint(
-        self, literal_context: UVLPythonParser.IntegerLiteralExpressionContext
-    ) -> Node:
-        """Process a string literal expression."""
-        return Node(literal_context.getText())
-
-    def process_binary_constraints(
-        self, context: UVLPythonParser.ConstraintContext, operation: ASTOperation
-    ) -> Node:
-        """Process a binary constraint."""
-        left_constraint = context.constraint(0)
-        right_constraint = context.constraint(1)
-        return Node(operation,
-                    self.process_constraints(left_constraint),
-                    self.process_constraints(right_constraint)
-                    )
-
-    def process_unary_constraint(
-        self, context: UVLPythonParser.ConstraintContext, operation: ASTOperation
-    ) -> Node:
-        """Process a unary constraint."""
-        inner_constraint = context.constraint()
-        return Node(operation, self.process_constraints(inner_constraint))
-
-    def process_binary_expression(self, context: Any, operation: ASTOperation) -> Node:
-        """Process a binary expression."""
-        left_constraint = context.expression(0)
-        right_constraint = context.expression(1)
-        return Node(operation,
-                    self.process_constraints(left_constraint),
-                    self.process_constraints(right_constraint)
-                    )
-
-    def process_literal(
-        self, literal_context: UVLPythonParser.LiteralConstraintContext
-    ) -> Node:
-        """Process a literal constraint."""
-        literal = literal_context.reference()
-        return Node(literal.getText().replace('"', ''))
-
-    def process_parenthesis_constraint(
-        self, parenthesis_context: UVLPythonParser.ParenthesisConstraintContext
-    ) -> Node:
-        """Process a parenthesis constraint."""
-        inner_constraint = parenthesis_context.constraint()
-        return self.process_constraints(inner_constraint)
-
-    def process_bracket_expression_constraint(
-        self, bracket_context: UVLPythonParser.BracketExpressionContext
-    ) -> Node:
-        """Process a bracket (parenthesis) expression constraint."""
-        inner_constraint = bracket_context.expression()
-        return self.process_constraints(inner_constraint)
-
-    def process_not_constraint(
-        self, not_context: UVLPythonParser.NotConstraintContext
-    ) -> Node:
-        """Process a not constraint."""
-        inner_constraint = not_context.constraint()
-        return Node(ASTOperation.NOT, self.process_constraints(inner_constraint))
+    def process_constraints(self, ctx: UVLPythonParser.ConstraintContext) -> Node:
+        # Logical operators (binary)
+        # Map for binary logical operators
+        binary_ops = {
+            UVLPythonParser.AndConstraintContext: ASTOperation.AND,
+            UVLPythonParser.OrConstraintContext: ASTOperation.OR,
+            UVLPythonParser.ImplicationConstraintContext: ASTOperation.IMPLIES,
+            UVLPythonParser.EquivalenceConstraintContext: ASTOperation.EQUIVALENCE,
+        }
+
+        ctx_type = type(ctx)
+        if ctx_type in binary_ops:
+            return self._binary_ctc(ctx, binary_ops[ctx_type])
+
+        # Logical operators (unary) and parenthesis
+        if isinstance(ctx, UVLPythonParser.NotConstraintContext):
+            return Node(ASTOperation.NOT, self.process_constraints(ctx.constraint()))
+        if isinstance(ctx, UVLPythonParser.ParenthesisConstraintContext):
+            return self.process_constraints(ctx.constraint())
+
+        # Leafs: Equations or simple referencesEcuaciones o Referencias simples
+        if isinstance(ctx, UVLPythonParser.EquationConstraintContext):
+            return self.process_equation(ctx.equation())
+        if isinstance(ctx, UVLPythonParser.LiteralConstraintContext):
+            return Node(ctx.reference().getText().replace('"', ''))  # procesar literal
+
+        raise NotImplementedError(f"Unknown type of constraint: {type(ctx)}")
+
+    def _binary_ctc(self, ctx: Any, op: ASTOperation) -> Node:
+        """Helper for binary operators"""
+        return Node(op, self.process_constraints(ctx.constraint(0)),
+                        self.process_constraints(ctx.constraint(1)))
+
+    def process_equation(self, ctx: UVLPythonParser.EquationContext) -> Node:
+        # Operators map
+        ops = {
+            UVLPythonParser.EqualEquationContext: ASTOperation.EQUALS,
+            UVLPythonParser.LowerEquationContext: ASTOperation.LOWER,
+            UVLPythonParser.GreaterEquationContext: ASTOperation.GREATER,
+            UVLPythonParser.LowerEqualsEquationContext: ASTOperation.LOWER_EQUALS,
+            UVLPythonParser.GreaterEqualsEquationContext: ASTOperation.GREATER_EQUALS,
+            UVLPythonParser.NotEqualsEquationContext: ASTOperation.NOT_EQUALS,
+        }
+        operator = ops.get(type(ctx))
+        return Node(operator, self.process_expression(ctx.expression(0)),
+                            self.process_expression(ctx.expression(1)))
+
+    def process_expression(self, ctx: Any) -> Node:
+        """Handle Additive, Multiplicative y Primary Expressions"""
+        # Binary expressions (arithmetics)
+        # 1. Handle Arithmetic Binary Expressions
+        arithmetic_ops = {
+            UVLPythonParser.AddExpressionContext: ASTOperation.ADD,
+            UVLPythonParser.SubExpressionContext: ASTOperation.SUB,
+            UVLPythonParser.MulExpressionContext: ASTOperation.MUL,
+            UVLPythonParser.DivExpressionContext: ASTOperation.DIV,
+        }
+
+        ctx_type = type(ctx)
+        if ctx_type in arithmetic_ops:
+            op = arithmetic_ops[ctx_type]
+            return Node(op, self.process_expression(ctx.expression(0)),
+                            self.process_expression(ctx.expression(1)))
+
+        # 2. Handle single-child expression (grammar fall-through)
+        if hasattr(ctx, 'expression') and callable(ctx.expression):
+            child = ctx.expression()
+            if child is not None:
+                return self.process_expression(child)
+
+        # 3. Delegate leaves to a specialized helper to reduce complexity
+        return self._process_expression_leaves(ctx)
+
+    def _process_expression_leaves(self, ctx: Any) -> Node:
+        """Helper to process literal leaves and primary expressions."""
+        if isinstance(ctx, UVLPythonParser.FloatLiteralExpressionContext):
+            return Node(float(ctx.getText()))
+        if isinstance(ctx, UVLPythonParser.IntegerLiteralExpressionContext):
+            return Node(int(ctx.getText()))
+        if isinstance(ctx, (UVLPythonParser.StringLiteralExpressionContext,
+                            UVLPythonParser.LiteralExpressionContext)):
+            return Node(ctx.getText().replace('"', '').replace("'", ''))
+        if isinstance(ctx, UVLPythonParser.BracketExpressionContext):
+            return self.process_expression(ctx.expression())
+        if isinstance(ctx, UVLPythonParser.AggregateFunctionExpressionContext):
+            return self.process_aggregate(ctx.aggregateFunction())
+
+        # Default fallback
+        return Node(ctx.getText().replace('"', '').replace("'", ''))
+
+    def process_aggregate(self, ctx: UVLPythonParser.AggregateFunctionContext) -> Node:
+        # 1. SUM: aggregateFunction -> sumAggregateFunction
+        if isinstance(ctx, UVLPythonParser.SumAggregateFunctionExpressionContext):
+            sub_ctx = ctx.sumAggregateFunction()
+            return self._build_aggregate_node(ASTOperation.SUM, sub_ctx.reference())
+
+        # 2. AVG: aggregateFunction -> avgAggregateFunction
+        if isinstance(ctx, UVLPythonParser.AvgAggregateFunctionExpressionContext):
+            sub_ctx = ctx.avgAggregateFunction()
+            return self._build_aggregate_node(ASTOperation.AVG, sub_ctx.reference())
+
+        # 3. STRING: aggregateFunction -> stringAggregateFunction
+        if isinstance(ctx, UVLPythonParser.StringAggregateFunctionExpressionContext):
+            string_func = ctx.stringAggregateFunction()
+            # Here we handle the tag # LengthAggregateFunction
+            if isinstance(string_func, UVLPythonParser.LengthAggregateFunctionContext):
+                return Node(ASTOperation.LEN, Node(string_func.reference().getText()))
+
+        # 4. NUMERIC: aggregateFunction -> numericAggregateFunction
+        if isinstance(ctx, UVLPythonParser.NumericAggregateFunctionExpressionContext):
+            num_func = ctx.numericAggregateFunction()
+            ref_node = Node(num_func.reference().getText())
+            # Handle tags # FloorAggregateFunction and # CeilAggregateFunction
+            if isinstance(num_func, UVLPythonParser.FloorAggregateFunctionContext):
+                return Node(ASTOperation.FLOOR, ref_node)
+            if isinstance(num_func, UVLPythonParser.CeilAggregateFunctionContext):
+                return Node(ASTOperation.CEIL, ref_node)
+
+        raise NotImplementedError(f"Aggregate function not supported: {type(ctx)}")
+
+    def _build_aggregate_node(self, operation: ASTOperation, references: list[Any]) -> Node:
+        """Helper for Sum y Avg that can take 1 or 2 references"""
+        nodes = [Node(r.getText().replace('"', '')) for r in references]
+        return Node(operation, *nodes)
 
     def process_includes(
         self, includes_node: UVLPythonParser.IncludesContext

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy/metamodels/fm_metamodel/transformations/xml_reader.py

@@ -1,4 +1,4 @@
-import sys
+import logging
 from typing import Optional
 from xml.etree import ElementTree
 
@@ -12,6 +12,8 @@ from flamapy.metamodels.fm_metamodel.models import (
     Relation,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class XMLReader(TextToModel):
 
@@ -39,7 +41,7 @@ class XMLReader(TextToModel):
                 ctc = self.parse_ctc(child)
                 feature_model.ctcs.append(ctc)
             else:
-                print("This XML contains non supported elements", file=sys.stderr)
+                logger.warning("This XML contains non supported elements")
 
         return feature_model
 
@@ -83,7 +85,7 @@ class XMLReader(TextToModel):
         feature = Feature(name, [], parent=parent)
 
         if name in self.name_feature:
-            print("This XML contains duplicated feature names", file=sys.stderr)
+            logger.warning("This XML contains duplicated feature names")
             raise DuplicatedFeature
 
         self.name_feature[name] = feature
@@ -113,7 +115,7 @@ class XMLReader(TextToModel):
                     relation.card_min = int(str(child.attrib.get('min')))
                     relation.card_max = int(str(child.attrib.get('max')))
                 else:
-                    print("This XML contains non supported elements", file=sys.stderr)
+                    logger.warning("This XML contains non supported elements")
 
         elif element.tag.casefold() == 'setrelation':
             for child in element:
@@ -124,7 +126,7 @@ class XMLReader(TextToModel):
                     relation.card_min = int(str(child.attrib.get('min')))
                     relation.card_max = int(str(child.attrib.get('max')))
                 else:
-                    print("This XML contains non supported elements", file=sys.stderr)
+                    logger.warning("This XML contains non supported elements")
         else:
             raise RuntimeError("Something is wrong on the xml")
         return relation

flamapy_fm-2.1.0.dev2/flamapy_fm.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: flamapy-fm
+Version: 2.1.0.dev2
+Summary: flamapy-fm is a plugin to Flamapy module
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/fm_metamodel
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: flamapy-fw~=2.1.0.dev2
+Requires-Dist: uvlparser~=2.0.1.dev61
+Requires-Dist: afmparser~=1.0.3
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: prospector; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: antlr4-tools; extra == "dev"
+Dynamic: license-file
+
+# fm_metamodel
+
+This repo host the feature model concrete classes
+
+
+## Install for development
+
+```
+pip install -e .
+```

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy_fm.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 setup.py

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/flamapy_fm.egg-info/requires.txt

@@ -1,5 +1,5 @@
-flamapy-fw~=2.1.0.dev0
-uvlparser~=2.0.1
+flamapy-fw~=2.1.0.dev2
+uvlparser~=2.0.1.dev61
 afmparser~=1.0.3
 
 [dev]

{flamapy-fm-2.1.0.dev0 → flamapy_fm-2.1.0.dev2}/pyproject.toml

@@ -1,11 +1,47 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flamapy-fm"
+version = "2.1.0.dev2"
+description = "flamapy-fm is a plugin to Flamapy module"
+readme = "README.md"
+license = "GPL-3.0-or-later"
+authors = [{ name = "Flamapy", email = "flamapy@us.es" }]
+requires-python = ">=3.9"
+dependencies = [
+    "flamapy-fw~=2.1.0.dev2",
+    "uvlparser~=2.0.1.dev61",
+    "afmparser~=1.0.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-mock",
+    "prospector",
+    "mypy",
+    "coverage",
+    "antlr4-tools",
+]
+
+[project.urls]
+Homepage = "https://github.com/flamapy/fm_metamodel"
+
+[tool.setuptools.packages.find]
+include = ["flamapy.*"]
+
 [tool.ruff]
 line-length = 100  # Matches max-line-length from pycodestyle
-target-version = "py38"  # Adjust if using another Python version
+target-version = "py39"
 
 [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
+    "RUF012",
+    "RUF002",
+    "RUF001",
 ]
 
 [tool.ruff.lint.mccabe]

flamapy_fm-2.1.0.dev2/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()

flamapy-fm-2.1.0.dev0/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.1
-Name: flamapy-fm
-Version: 2.1.0.dev0
-Summary: flamapy-fm is a plugin to Flamapy module
-Home-page: https://github.com/flamapy/fm_metamodel
-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
-
-# fm_metamodel
-
-This repo host the feature model concrete classes
-
-
-## Install for development
-
-```
-pip install -e .
-```
-
-

flamapy-fm-2.1.0.dev0/flamapy_fm.egg-info/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.1
-Name: flamapy-fm
-Version: 2.1.0.dev0
-Summary: flamapy-fm is a plugin to Flamapy module
-Home-page: https://github.com/flamapy/fm_metamodel
-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
-
-# fm_metamodel
-
-This repo host the feature model concrete classes
-
-
-## Install for development
-
-```
-pip install -e .
-```
-
-

flamapy-fm-2.1.0.dev0/setup.py

@@ -1,37 +0,0 @@
-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.1.0.dev0",
-    author="Flamapy",
-    author_email="flamapy@us.es",
-    description="flamapy-fm is a plugin to Flamapy module",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/flamapy/fm_metamodel",
-    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',
-    install_requires=requirements,
-    extras_require={
-        'dev': dev_requirements
-    },
-)