flamapy-fm 2.5.0.dev0__tar.gz → 2.6.0.dev0__tar.gz

{flamapy_fm-2.5.0.dev0/flamapy_fm.egg-info → flamapy_fm-2.6.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-fm
-Version: 2.5.0.dev0
+Version: 2.6.0.dev0
 Summary: flamapy-fm is a plugin to Flamapy module
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,8 +8,8 @@ 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.5.0.dev0
-Requires-Dist: uvlparser~=2.5.0.dev63
+Requires-Dist: flamapy-fw~=2.6.0.dev0
+Requires-Dist: uvlparser~=2.5.0
 Requires-Dist: afmparser~=1.0.3
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -20,13 +20,16 @@ Requires-Dist: coverage; extra == "dev"
 Requires-Dist: antlr4-tools; extra == "dev"
 Dynamic: license-file
 
-# fm_metamodel
+# flamapy-fm
 
-This repo host the feature model concrete classes
+The feature model metamodel plugin for [flamapy](https://flamapy.org): the
+feature model classes plus readers and writers for many formats (UVL,
+FeatureIDE, Glencoe, AFM, SPLOT, JSON, …).
 
+**Documentation:** https://docs.flamapy.org/framework/plugins/feature_model_plugin
 
-## Install for development
+## Installation
 
-```
-pip install -e .
+```bash
+pip install flamapy-fm
 ```

flamapy_fm-2.6.0.dev0/README.md

@@ -0,0 +1,13 @@
+# flamapy-fm
+
+The feature model metamodel plugin for [flamapy](https://flamapy.org): the
+feature model classes plus readers and writers for many formats (UVL,
+FeatureIDE, Glencoe, AFM, SPLOT, JSON, …).
+
+**Documentation:** https://docs.flamapy.org/framework/plugins/feature_model_plugin
+
+## Installation
+
+```bash
+pip install flamapy-fm
+```

{flamapy_fm-2.5.0.dev0 → flamapy_fm-2.6.0.dev0}/flamapy/metamodels/fm_metamodel/models/feature_model.py

@@ -3,7 +3,7 @@ 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 import AST, VariabilityModel, VariabilityElement, ASTOperation, NodeType
 from flamapy.core.models.ast import LOGICAL_OPERATORS, ARITHMETIC_OPERATORS, AGGREGATION_OPERATORS
 from flamapy.core.models.ast import simplify_formula, propagate_negation, to_cnf
 
@@ -247,7 +247,11 @@ class Constraint:
         self._ast = ast
 
     def get_features(self) -> list[str]:
-        """List of features' names involved in the constraint."""
+        """List of features' names involved in the constraint.
+
+        Uses node_type information when available (set by readers that support it).
+        Falls back to heuristics for nodes without explicit type info.
+        """
         features = set()
         stack = [self.ast.root]
         while stack:
@@ -255,9 +259,15 @@ class Constraint:
             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)
+                if node.node_type is not None:
+                    if node.node_type == NodeType.FEATURE:
+                        features.add(node.data)
+                    # NodeType.LITERAL: skip
+                # Fallback heuristics for nodes without explicit type (backward compatibility)
+                elif not isinstance(node.data, (int, float)) and not (
+                    isinstance(node.data, str) and node.data.startswith("'")
+                ):
+                    features.add(node.data)
             elif node.is_unary_op():
                 stack.append(node.left)
             elif node.is_binary_op():
@@ -281,8 +291,7 @@ class Constraint:
         """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())))
+                (root_op.data == ASTOperation.NOT and root_op.left.is_term()))
 
     def is_simple_constraint(self) -> bool:
         """Return true if the constraint is a simple constraint (requires or excludes)."""

{flamapy_fm-2.5.0.dev0 → flamapy_fm-2.6.0.dev0}/flamapy/metamodels/fm_metamodel/transformations/__init__.py

@@ -8,6 +8,7 @@ from .splot_writer import SPLOTWriter
 from .uvl_reader import UVLReader
 from .uvl_writer import UVLWriter
 from .xml_reader import XMLReader
+from .xml_writer import XMLWriter
 from .glencoe_reader import GlencoeReader
 from .glencoe_writer import GlencoeWriter
 from .clafer_writer import ClaferWriter
@@ -33,4 +34,5 @@ __all__ = [
            'UVLReader',
            'UVLWriter',
            'XMLReader',
+           'XMLWriter',
 ]

{flamapy_fm-2.5.0.dev0 → flamapy_fm-2.6.0.dev0}/flamapy/metamodels/fm_metamodel/transformations/uvl_reader.py

@@ -9,7 +9,7 @@ from uvl.UVLPythonParser import UVLPythonParser
 
 from flamapy.core.exceptions import FlamaException
 from flamapy.core.transformations import TextToModel
-from flamapy.core.models.ast import AST, ASTOperation, Node
+from flamapy.core.models.ast import AST, ASTOperation, Node, NodeType
 from flamapy.metamodels.fm_metamodel.models import (
     Constraint,
     Feature,
@@ -169,7 +169,7 @@ class UVLReader(TextToModel):
                 feature_type = FeatureType.REAL
             else:
                 raise FlamaException('Error: unknow feature type for '
-                                     f'{typed_text} of feature {feature.name}.')
+                                     f'{typed_text} of feature "{feature.name}".')
             feature.feature_type = feature_type
 
     def _check_attributes(
@@ -233,7 +233,7 @@ class UVLReader(TextToModel):
                 raise FlamaException(f'Feature {feature_reference_name} not found in '
                                      f'imported model {namespace}.')
 
-    def process_relationship_type(self,
+    def process_relationship_type(self,  # noqa: C901 - flat dispatch over UVL group types
                                   feature: Feature,
                                   feature_node: UVLPythonParser.FeatureContext) -> None:
         for relationship in feature_node.group():
@@ -255,7 +255,13 @@ class UVLReader(TextToModel):
                 feature.add_relation(Relation(feature, childs, min_value, max_value))
                 if max_value > len(childs):
                     logging.warning(
-                        "Cardinality error: max value is greater than the number of childs"
+                        f'Cardinality error in feature "{feature.name}": '
+                        'max value is greater than the number of childs'
+                    )
+                if min_value < 0:
+                    logging.warning(
+                        f'Cardinality error in feature "{feature.name}": '
+                        'min value cannot be negative'
                     )
 
     def process_feature(
@@ -328,7 +334,7 @@ class UVLReader(TextToModel):
         if isinstance(ctx, UVLPythonParser.EquationConstraintContext):
             return self.process_equation(ctx.equation())
         if isinstance(ctx, UVLPythonParser.LiteralConstraintContext):
-            return Node(ctx.reference().getText().replace('"', ''))  # procesar literal
+            return Node(ctx.reference().getText().replace('"', ''), node_type=NodeType.FEATURE)
 
         raise NotImplementedError(f"Unknown type of constraint: {type(ctx)}")
 
@@ -388,22 +394,23 @@ class UVLReader(TextToModel):
                     self.process_expression(ctx.multiplicativeExpression()),
                     self.process_expression(ctx.primaryExpression()))
 
-    def _process_expression_leaves(self, ctx: Any) -> Node:
+    def _process_expression_leaves(self, ctx: Any) -> Node:  # noqa: PLR0911 - one return per UVL leaf type
         """Helper to process literal leaves and primary expressions."""
         if isinstance(ctx, UVLPythonParser.FloatLiteralExpressionContext):
-            return Node(float(ctx.getText()))
+            return Node(float(ctx.getText()), node_type=NodeType.LITERAL)
         if isinstance(ctx, UVLPythonParser.IntegerLiteralExpressionContext):
-            return Node(int(ctx.getText()))
-        if isinstance(ctx, (UVLPythonParser.StringLiteralExpressionContext,
-                            UVLPythonParser.LiteralExpressionContext)):
-            return Node(ctx.getText().replace('"', '').replace("'", ''))
+            return Node(int(ctx.getText()), node_type=NodeType.LITERAL)
+        if isinstance(ctx, UVLPythonParser.StringLiteralExpressionContext):
+            return Node(ctx.getText().replace('"', '').replace("'", ''), node_type=NodeType.LITERAL)
+        if isinstance(ctx, UVLPythonParser.LiteralExpressionContext):
+            return Node(ctx.getText().replace('"', '').replace("'", ''), node_type=NodeType.FEATURE)
         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("'", ''))
+        # Default fallback: treat as feature reference
+        return Node(ctx.getText().replace('"', '').replace("'", ''), node_type=NodeType.FEATURE)
 
     def process_aggregate(self, ctx: UVLPythonParser.AggregateFunctionContext) -> Node:
         # 1. SUM: aggregateFunction -> sumAggregateFunction
@@ -419,14 +426,17 @@ class UVLReader(TextToModel):
         # 3. STRING: aggregateFunction -> stringAggregateFunction
         if isinstance(ctx, UVLPythonParser.StringAggregateFunctionExpressionContext):
             string_func = ctx.stringAggregateFunction()
+            ref_node = Node(string_func.reference().getText().replace('"', ''),
+                            node_type=NodeType.FEATURE)
             # Here we handle the tag # LengthAggregateFunction
             if isinstance(string_func, UVLPythonParser.LengthAggregateFunctionContext):
-                return Node(ASTOperation.LEN, Node(string_func.reference().getText()))
+                return Node(ASTOperation.LEN, ref_node)
 
         # 4. NUMERIC: aggregateFunction -> numericAggregateFunction
         if isinstance(ctx, UVLPythonParser.NumericAggregateFunctionExpressionContext):
             num_func = ctx.numericAggregateFunction()
-            ref_node = Node(num_func.reference().getText())
+            ref_node = Node(num_func.reference().getText().replace('"', ''),
+                            node_type=NodeType.FEATURE)
             # Handle tags # FloorAggregateFunction and # CeilAggregateFunction
             if isinstance(num_func, UVLPythonParser.FloorAggregateFunctionContext):
                 return Node(ASTOperation.FLOOR, ref_node)
@@ -437,7 +447,7 @@ class UVLReader(TextToModel):
 
     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]
+        nodes = [Node(r.getText().replace('"', ''), node_type=NodeType.FEATURE) for r in references]
         return Node(operation, *nodes)
 
     def process_includes(

flamapy_fm-2.6.0.dev0/flamapy/metamodels/fm_metamodel/transformations/xml_writer.py

@@ -0,0 +1,140 @@
+import logging
+from xml.dom import minidom
+import xml.etree.ElementTree as ET
+
+from flamapy.core.models.ast import ASTOperation
+from flamapy.core.transformations import ModelToText
+
+from flamapy.metamodels.fm_metamodel.models import Feature, FeatureModel, Relation
+
+logger = logging.getLogger(__name__)
+
+
+class XMLWriter(ModelToText):
+    """Serialize a FeatureModel to FAMA XML format.
+
+    This is the counterpart of XMLReader. The output is readable by XMLReader
+    and compatible with the FaMA analysis tool.
+
+    Only requires/excludes cross-tree constraints are supported by this format.
+    Complex constraints are skipped; inspect ``skipped_constraints`` after
+    calling ``transform()`` to retrieve the ones that were dropped.
+    """
+
+    @staticmethod
+    def get_destination_extension() -> str:
+        return 'xml'
+
+    def __init__(self, path: str, source_model: FeatureModel) -> None:
+        self._path = path
+        self._source_model = source_model
+        self.skipped_constraints: list[str] = []
+
+    def transform(self) -> str:
+        self.skipped_constraints = []
+
+        fm_el = ET.Element('feature-model')
+        fm_el.set('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance')
+        fm_el.set('xsi:noNamespaceSchemaLocation', 'feature-model-schema.xsd')
+
+        root_feature = self._source_model.root
+        feat_el = ET.SubElement(fm_el, 'feature')
+        feat_el.set('name', root_feature.name)
+
+        counters = [0, 0]  # [br_count, sr_count]
+        _write_feature(root_feature, feat_el, counters)
+
+        requires_list, excludes_list = self._extract_binary_constraints()
+
+        re_count = 0
+        for feat_a, feat_b in requires_list:
+            re_count += 1
+            req_el = ET.SubElement(fm_el, 'requires')
+            req_el.set('name', f'Re-{re_count}')
+            req_el.set('feature', feat_a)
+            req_el.set('requires', feat_b)
+
+        ex_count = 0
+        for feat_a, feat_b in excludes_list:
+            ex_count += 1
+            exc_el = ET.SubElement(fm_el, 'excludes')
+            exc_el.set('name', f'Ex-{ex_count}')
+            exc_el.set('feature', feat_a)
+            exc_el.set('excludes', feat_b)
+
+        rough_str = ET.tostring(fm_el, encoding='unicode')
+        dom = minidom.parseString(rough_str)
+        lines = dom.toprettyxml(indent='\t').splitlines()
+        if lines and lines[0].startswith('<?xml'):
+            lines[0] = '<?xml version="1.0" encoding="UTF-8"?>'
+        xml_str = '\n'.join(lines)
+
+        if self._path is not None:
+            with open(self._path, 'w', encoding='utf-8') as fh:
+                fh.write(xml_str)
+
+        return xml_str
+
+    def _extract_binary_constraints(
+        self,
+    ) -> tuple[list[tuple[str, str]], list[tuple[str, str]]]:
+        requires_list: list[tuple[str, str]] = []
+        excludes_list: list[tuple[str, str]] = []
+        for constraint in self._source_model.get_constraints():
+            raw = str(constraint)
+            ast_root = constraint.ast.root
+            op = getattr(ast_root.data, 'value', str(ast_root.data)).upper()
+            left = ast_root.left
+            right = ast_root.right
+            if (
+                left is not None
+                and right is not None
+                and left.is_term()
+                and right.is_term()
+            ):
+                if op in ('REQUIRES', 'IMPLIES', '=>') or ast_root.data is ASTOperation.REQUIRES:
+                    requires_list.append((str(left.data), str(right.data)))
+                    continue
+                if op == 'EXCLUDES' or ast_root.data is ASTOperation.EXCLUDES:
+                    excludes_list.append((str(left.data), str(right.data)))
+                    continue
+            logger.warning('Constraint skipped (unsupported in XML format): %s', raw)
+            self.skipped_constraints.append(raw)
+        return requires_list, excludes_list
+
+
+def _write_feature(feature: Feature, parent_el: ET.Element, counters: list[int]) -> None:
+    """Recursively append FAMA XML child elements to *parent_el*."""
+    for relation in feature.get_relations():
+        _write_relation(relation, parent_el, counters)
+
+
+def _write_relation(relation: Relation, parent_el: ET.Element, counters: list[int]) -> None:
+    children = list(relation.children)
+    if len(children) == 1:
+        counters[0] += 1
+        br_el = ET.SubElement(parent_el, 'binaryRelation')
+        br_el.set('name', f'BR-{counters[0]}')
+
+        card_el = ET.SubElement(br_el, 'cardinality')
+        card_el.set('min', str(relation.card_min))
+        card_el.set('max', str(relation.card_max))
+
+        child = children[0]
+        sol_el = ET.SubElement(br_el, 'solitaryFeature')
+        sol_el.set('name', child.name)
+        _write_feature(child, sol_el, counters)
+
+    elif len(children) > 1:
+        counters[1] += 1
+        sr_el = ET.SubElement(parent_el, 'setRelation')
+        sr_el.set('name', f'SR-{counters[1]}')
+
+        card_el = ET.SubElement(sr_el, 'cardinality')
+        card_el.set('min', str(relation.card_min))
+        card_el.set('max', str(relation.card_max))
+
+        for child in children:
+            gf_el = ET.SubElement(sr_el, 'groupedFeature')
+            gf_el.set('name', child.name)
+            _write_feature(child, gf_el, counters)

{flamapy_fm-2.5.0.dev0 → flamapy_fm-2.6.0.dev0/flamapy_fm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-fm
-Version: 2.5.0.dev0
+Version: 2.6.0.dev0
 Summary: flamapy-fm is a plugin to Flamapy module
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,8 +8,8 @@ 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.5.0.dev0
-Requires-Dist: uvlparser~=2.5.0.dev63
+Requires-Dist: flamapy-fw~=2.6.0.dev0
+Requires-Dist: uvlparser~=2.5.0
 Requires-Dist: afmparser~=1.0.3
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -20,13 +20,16 @@ Requires-Dist: coverage; extra == "dev"
 Requires-Dist: antlr4-tools; extra == "dev"
 Dynamic: license-file
 
-# fm_metamodel
+# flamapy-fm
 
-This repo host the feature model concrete classes
+The feature model metamodel plugin for [flamapy](https://flamapy.org): the
+feature model classes plus readers and writers for many formats (UVL,
+FeatureIDE, Glencoe, AFM, SPLOT, JSON, …).
 
+**Documentation:** https://docs.flamapy.org/framework/plugins/feature_model_plugin
 
-## Install for development
+## Installation
 
-```
-pip install -e .
+```bash
+pip install flamapy-fm
 ```

{flamapy_fm-2.5.0.dev0 → flamapy_fm-2.6.0.dev0}/flamapy_fm.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ flamapy/metamodels/fm_metamodel/transformations/splot_writer.py
 flamapy/metamodels/fm_metamodel/transformations/uvl_reader.py
 flamapy/metamodels/fm_metamodel/transformations/uvl_writer.py
 flamapy/metamodels/fm_metamodel/transformations/xml_reader.py
+flamapy/metamodels/fm_metamodel/transformations/xml_writer.py
 flamapy/metamodels/fm_metamodel/transformations/refactorings/__init__.py
 flamapy/metamodels/fm_metamodel/transformations/refactorings/cardinality_group_refactoring.py
 flamapy/metamodels/fm_metamodel/transformations/refactorings/commitment_feature.py

{flamapy_fm-2.5.0.dev0 → flamapy_fm-2.6.0.dev0}/flamapy_fm.egg-info/requires.txt

@@ -1,5 +1,5 @@
-flamapy-fw~=2.5.0.dev0
-uvlparser~=2.5.0.dev63
+flamapy-fw~=2.6.0.dev0
+uvlparser~=2.5.0
 afmparser~=1.0.3
 
 [dev]

{flamapy_fm-2.5.0.dev0 → flamapy_fm-2.6.0.dev0}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flamapy-fm"
-version = "2.5.0.dev0"
+version = "2.6.0.dev0"
 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.5.0.dev0",
-    "uvlparser~=2.5.0.dev63",
+    "flamapy-fw~=2.6.0.dev0",
+    "uvlparser~=2.5.0",
     "afmparser~=1.0.3",
 ]
 

flamapy_fm-2.5.0.dev0/README.md

@@ -1,10 +0,0 @@
-# fm_metamodel
-
-This repo host the feature model concrete classes
-
-
-## Install for development
-
-```
-pip install -e .
-```