flamapy-fm 2.6.0.dev11__tar.gz → 2.9.0.dev0__tar.gz

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-fm
-Version: 2.6.0.dev11
+Version: 2.9.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,7 +8,7 @@ Project-URL: Homepage, https://github.com/flamapy/fm_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.6.0.dev11
+Requires-Dist: flamapy-fw~=2.9.0.dev0
 Requires-Dist: uvlparser~=2.5.0
 Requires-Dist: afmparser~=1.0.3
 Provides-Extra: dev
@@ -18,6 +18,10 @@ Requires-Dist: prospector; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: antlr4-tools; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: flamapy-sat~=2.9.0.dev0; extra == "test"
+Requires-Dist: flamapy-bdd~=2.9.0.dev0; extra == "test"
 Dynamic: license-file
 
 # flamapy-fm

flamapy_fm-2.9.0.dev0/flamapy/metamodels/fm_metamodel/__init__.py

@@ -0,0 +1,26 @@
+from flamapy.core.manifest import OperationCapability, PluginManifest
+from flamapy.core.models.language_level import ALL_MINOR_LEVELS, LanguageLevel, MajorLevel
+
+# The metamodel itself understands the full UVL language; its own (tree-level)
+# operations run on any model. Costs are estimated milliseconds measured on 2026-11-08 on the
+# betty calibration models (1% and 30% density, 1,000-10,000 features): both operations walk
+# the tree once, core features in under 1 ms and atomic sets in 7 ms at 10,000 features.
+MANIFEST = PluginManifest(
+    name='fm',
+    calibration='2026-11-08',
+    extension='fm',
+    supported_level=LanguageLevel(MajorLevel.TYPE, set(ALL_MINOR_LEVELS)),
+    operations={
+        # FMCoreFeatures reads the tree only (mandatory chains from the root) and ignores
+        # the cross-tree constraints: an estimate, never chosen by the planner unless the
+        # caller allows approximate results.
+        'core_features': OperationCapability(exact=False, cost=1),
+        # FMAtomicSets groups mandatory features with their parents and ignores the
+        # cross-tree constraints, which can merge sets: an estimate as well.
+        'atomic_sets': OperationCapability(
+            exact=False, cost_curve=((1000, 1), (2000, 2), (5000, 4), (10000, 7))),
+        # The estimated number of configurations is, by definition, an estimate (2 ms at
+        # 10,000 features).
+        'estimated_number_of_configurations': OperationCapability(exact=False, cost=2),
+    },
+)

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/flamapy/metamodels/fm_metamodel/models/__init__.py

@@ -10,9 +10,10 @@ from .feature_model import (
     FeatureType,
     AttributeType
 )
-from .clause_set import ClauseSet
+from .clause_set import DEFAULT_CNF_METHOD, ClauseSet
 
 __all__ = [
+    'DEFAULT_CNF_METHOD',
     'Attribute',
     'AttributeType',
     'Cardinality',

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/flamapy/metamodels/fm_metamodel/models/clause_set.py

@@ -10,9 +10,10 @@ their representation from this single encoding.
 """
 import itertools
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from typing import Any, Callable, Optional
 
 from flamapy.core.exceptions import FlamaException
+from flamapy.core.models.ast import AST, ASTOperation, Node
 
 from flamapy.metamodels.fm_metamodel.models.feature_model import (
     FeatureModel,
@@ -22,6 +23,11 @@ from flamapy.metamodels.fm_metamodel.models.feature_model import (
 )
 
 
+# The encoding every CNF consumer uses unless told otherwise (FmToPysat, FmToDiagPysat, FmToSDD,
+# FmToSharpSAT, FmToDDNNF): import it rather than repeating the literal.
+DEFAULT_CNF_METHOD = 'auto'
+
+
 @dataclass
 class ClauseSet:
     """CNF encoding of a feature model as signed-integer clauses plus name/id maps."""
@@ -42,17 +48,90 @@ class ClauseSet:
 
     @classmethod
     def from_feature_model(
-        cls, feature_model: FeatureModel, cnf_method: str = 'distributive'
+        cls, feature_model: FeatureModel, cnf_method: str = DEFAULT_CNF_METHOD
     ) -> 'ClauseSet':
         """Encode ``feature_model`` into CNF.
 
         ``cnf_method`` controls only how cross-tree constraints are turned into clauses:
-        ``'distributive'`` (default) expands them directly, ``'tseytin'`` introduces auxiliary
-        variables for a compact, model-count-preserving encoding.
+        ``'distributive'`` expands them directly, ``'tseytin'`` introduces auxiliary variables
+        for a compact, model-count-preserving encoding, and ``'auto'`` (the default since 2.9)
+        decides per constraint: it expands a constraint directly unless the expansion would be
+        larger than its Tseytin encoding (see `distributive_clause_count`), so only constraints
+        that blow up (e.g. disjunctions of conjunctions, wide equivalences) get auxiliary
+        variables. On the SoSyM benchmark corpus ``'auto'`` encodes 1,409 of 1,538 models exactly
+        as ``'distributive'`` does; on the other 129 it produces fewer clauses (never more than
+        7,000 where the expansion reaches 51,000), encodes 2.5x faster and gives the same
+        results for every operation.
         """
+        if cnf_method not in CNF_METHODS:
+            raise FlamaException(f'Unknown cnf_method {cnf_method!r}; expected one of '
+                                 f'{", ".join(CNF_METHODS)}.')
         return _Encoder(cnf_method).encode(feature_model)
 
 
+CNF_METHODS = ('distributive', 'tseytin', 'auto')
+BINARY = 2
+
+
+# Clause counts of (P op Q) and of its negation, from the counts of P and Q in both polarities,
+# following flamapy's rewriting (simplify_formula): P => Q as !P | Q, P excludes Q as !P | !Q,
+# P <=> Q as (P => Q) & (Q => P), P xor Q as (P & !Q) | (!P & Q). A conjunction adds the clauses
+# of its operands, a disjunction multiplies them.
+_COUNT_RULES: dict[ASTOperation, Callable[[int, int, int, int], tuple[int, int]]] = {
+    ASTOperation.AND: lambda ap, an, bp, bn: (ap + bp, an * bn),
+    ASTOperation.OR: lambda ap, an, bp, bn: (ap * bp, an + bn),
+    ASTOperation.IMPLIES: lambda ap, an, bp, bn: (an * bp, ap + bn),
+    ASTOperation.REQUIRES: lambda ap, an, bp, bn: (an * bp, ap + bn),
+    ASTOperation.EXCLUDES: lambda ap, an, bp, bn: (an * bn, ap + bp),
+    ASTOperation.EQUIVALENCE: lambda ap, an, bp, bn: (an * bp + ap * bn, ap * bp + an * bn),
+    ASTOperation.XOR: lambda ap, an, bp, bn: ((ap + bn) * (an + bp), an * bp + ap * bn),
+}
+
+
+def distributive_clause_count(ast: AST) -> Optional[int]:
+    """Number of clauses the distributive CNF expansion of `ast` produces, computed without
+    building it (duplicates and subsumed clauses are not removed, as in the expansion itself).
+
+    Each node is counted for both polarities (see _COUNT_RULES), in one iterative pass, so deep
+    constraints do not hit the recursion limit. Returns None for non-propositional operators.
+    """
+    pos: dict[int, int] = {}
+    neg: dict[int, int] = {}
+    stack: list[tuple[Node, bool]] = [(ast.root, False)]
+    while stack:
+        node, expanded = stack.pop()
+        if node.is_term():
+            pos[id(node)] = neg[id(node)] = 1
+            continue
+        children = [child for child in (node.left, node.right) if child is not None]
+        if not expanded:
+            stack.append((node, True))
+            stack.extend((child, False) for child in children)
+            continue
+        if any(id(child) not in pos for child in children):
+            return None
+        if node.data == ASTOperation.NOT:
+            pos[id(node)], neg[id(node)] = neg[id(children[0])], pos[id(children[0])]
+        elif node.data in _COUNT_RULES and len(children) == BINARY:
+            left, right = children
+            pos[id(node)], neg[id(node)] = _COUNT_RULES[node.data](
+                pos[id(left)], neg[id(left)], pos[id(right)], neg[id(right)])
+        else:
+            return None
+    return pos[id(ast.root)]
+
+
+def tseytin_clause_estimate(ast: AST) -> int:
+    """Approximate size of the Tseytin encoding: about three clauses per operator, plus one."""
+    return 3 * sum(1 for _ in ast.get_operators()) + 1
+
+
+def use_tseytin(ast: AST) -> bool:
+    """The `auto` rule: Tseytin when the distributive expansion would be larger."""
+    count = distributive_clause_count(ast)
+    return count is not None and count > tseytin_clause_estimate(ast)
+
+
 class _Encoder:
     """Ported ~1:1 from the SAT plugin's FmToPysat so the produced clauses are identical."""
 
@@ -145,15 +224,9 @@ class _Encoder:
                         else:
                             cnf.append(self._get_variable(feat.name))
                     clauses.append(cnf)
-        for val in range(1, len(relation.children) + 1):
-            for combination in itertools.combinations(relation.children, val):
-                cnf = [parent]
-                for feat in relation.children:
-                    if feat in combination:
-                        cnf.append(-self._get_variable(feat.name))
-                    else:
-                        cnf.append(self._get_variable(feat.name))
-                clauses.append(cnf)
+        # Every selected child implies the parent: one binary clause per child.
+        for feat in relation.children:
+            clauses.append([-self._get_variable(feat.name), parent])
         return clauses
 
     def _add_relation(self, relation: Relation) -> None:
@@ -180,7 +253,10 @@ class _Encoder:
         return aux_map
 
     def _add_constraint(self, ctc: Constraint) -> None:
-        if self.cnf_method == 'tseytin':
+        method = self.cnf_method
+        if method == 'auto':
+            method = 'tseytin' if use_tseytin(ctc.ast) else 'distributive'
+        if method == 'tseytin':
             clauses, aux_names = ctc.ast.get_clauses_with_aux(method='tseytin')
             aux_map = self._allocate_auxiliary(aux_names)
         else:

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

@@ -118,7 +118,7 @@ class Cardinality:
 @total_ordering
 class Feature(VariabilityElement):
 
-    def __init__(  # noqa: PLR0913
+    def __init__(  # noqa: PLR0913, PLR0917
         self,
         name: str,
         relations: Optional[list["Relation"]] = None,
@@ -398,6 +398,23 @@ class FeatureModel(VariabilityModel):
         self.ctcs = [] if constraints is None else constraints
         self.imports: dict[str, FeatureModel] = {}  # namespace -> FeatureModel
         self.alias_namespace: dict[str, str] = {}  # alias -> namespace
+        self._canonical_hash: Optional[str] = None
+
+    def canonical_hash(self) -> Optional[str]:
+        """sha256 of the model's canonical UVL serialization, memoized.
+
+        Mutating the model does not invalidate the memo — hash before editing, or build a
+        fresh FeatureModel. (UVLWriter is imported lazily: transformations import models.)
+        """
+        if self._canonical_hash is None:
+            import hashlib  # noqa: PLC0415
+            # Lazy: transformations import models, so this import cannot be top-level.
+            from flamapy.metamodels.fm_metamodel.transformations.uvl_writer import (  # noqa: PLC0415  pylint: disable=import-outside-toplevel,cyclic-import
+                UVLWriter,
+            )
+            uvl = UVLWriter(path=None, source_model=self).transform()  # type: ignore[arg-type]
+            self._canonical_hash = hashlib.sha256(uvl.encode('utf-8')).hexdigest()
+        return self._canonical_hash
 
     def get_relations(self, feature: Optional["Feature"] = None) -> list["Relation"]:
         if self.root is None or self.root.is_empty():

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/flamapy/metamodels/fm_metamodel/operations/fm_atomic_sets.py

@@ -1,25 +1,18 @@
-from typing import Any, cast
+from typing import cast
 
 from flamapy.core.models import VariabilityModel
 from flamapy.core.operations.atomic_sets import AtomicSets
-from flamapy.core.operations.descriptor import OperationDescriptor
 from flamapy.metamodels.fm_metamodel.models import FeatureModel, Feature
 
 
-def _atomic_sets_result(result: Any) -> Any:
-    return [[feature.name for feature in atomic_set] for atomic_set in result]
-
-
 class FMAtomicSets(AtomicSets):
-    facade = OperationDescriptor(
-        doc=(
-            'This operation is used to find the atomic sets in a model: It returns the\n'
-            'atomic sets if they are found in the model. If the model does not follow the\n'
-            'UVL specification, an exception is raised and the operation returns False.'
-        ),
-        returns='Union[None, List[List[Any]]]',
-        name='atomic_sets', operation='FMAtomicSets', result_adapter=_atomic_sets_result
-    )
+    """The atomic sets read from the feature tree: the root with its chain of mandatory
+    descendants, and every other feature with its own chain. Cross-tree constraints, which
+    can merge sets, are ignored (the facade descriptor is the interface's; the exact sets are
+    computed by the solver-based implementations)."""
+
+    # Ignores the cross-tree constraints: reported in the OperationResult provenance envelope.
+    exact = False
 
     def __init__(self) -> None:
         self.result: list[set[Feature]] = []

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/flamapy/metamodels/fm_metamodel/operations/fm_core_features.py

@@ -18,6 +18,10 @@ class FMCoreFeatures(CoreFeatures):
         false-optional features (e.g., for 'requires' constraints).
     """
 
+    # Reads the tree only, so the result can miss core features that cross-tree constraints
+    # force: reported in the OperationResult provenance envelope.
+    exact = False
+
     def __init__(self) -> None:
         self.result: list[Feature] = []
 

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/flamapy/metamodels/fm_metamodel/operations/fm_estimated_configurations_number.py

@@ -16,6 +16,8 @@ class FMEstimatedConfigurationsNumber(EstimatedConfigurationsNumber):
     and thus, the number is an upper limit of the real number of products.
     """
 
+    exact = False  # reported in the OperationResult provenance envelope
+
     facade = OperationDescriptor(
         doc=(
             'This is an estimate of the total number of different products that can be\n'

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/flamapy/metamodels/fm_metamodel/operations/fm_language_level.py

@@ -1,37 +1,19 @@
-from enum import Enum, auto
-from dataclasses import dataclass, field
 from typing import cast
 
 from flamapy.core.models import VariabilityModel, ASTOperation
+# LanguageLevel/MajorLevel/MinorLevel moved to flamapy.core.models.language_level (they now
+# also describe plugin capability manifests); re-exported here for compatibility until 3.0.
+from flamapy.core.models.language_level import (
+    LanguageLevel,
+    MajorLevel,
+    MinorLevel,
+)
 from flamapy.core.operations import Operation
 from flamapy.core.operations.descriptor import OperationDescriptor
 
 from flamapy.metamodels.fm_metamodel.models import FeatureModel, Constraint
 
 
-class MajorLevel(Enum):
-    BOOLEAN = 1
-    ARITHMETIC = 2
-    TYPE = 3
-
-
-class MinorLevel(Enum):
-    STRING_CONSTRAINTS = auto()
-    FEATURE_CARDINALITY = auto()
-    AGGREGATE_FUNCTION = auto()
-    GROUP_CARDINALITY = auto()
-
-
-@dataclass(order=True, frozen=True)
-class LanguageLevel:
-    major: MajorLevel
-    minors: set[MinorLevel] = field(default_factory=set)
-
-    def __str__(self) -> str:
-        minors_str = ', '.join(ext.name for ext in sorted(self.minors, key=lambda x: x.name))
-        return f'Major: {self.major.name}, Minor: {{{minors_str}}}'
-
-
 class FMLanguageLevel(Operation):
     """Operation to calculate the maximum language level of a feature model."""
 

flamapy_fm-2.9.0.dev0/flamapy/metamodels/fm_metamodel/transformations/_uvl_lexer.py

@@ -0,0 +1,67 @@
+"""Work around a lexer slowdown in uvlparser <= 2.5.0.
+
+The generated UVL lexer's NEWLINE rule starts with the semantic predicate
+``{self.atStartOfInput()}?``. ANTLR never caches the lexer's DFA start state when a predicate
+is reachable from it, so every token recomputes the full ATN closure (~6x slower parsing).
+
+The predicate is ``line == 1 and column == 0``, so it can only hold on the very first token.
+The simulator below bypasses the start-state cache on that token and caches it everywhere
+else, where the predicate is false and the closure does not depend on the position. Lexing
+results are identical, including the rejection of an indented first line.
+
+Once uvlparser ships a lexer without the predicate this becomes a no-op and can be removed.
+"""
+from typing import Any
+
+from antlr4 import InputStream
+from antlr4.PredictionContext import PredictionContextCache
+from antlr4.atn.LexerATNSimulator import LexerATNSimulator
+from antlr4.dfa.DFA import DFA
+from uvl.UVLCustomLexer import UVLCustomLexer
+from uvl.UVLPythonLexer import UVLPythonLexer
+
+NEEDS_WORKAROUND = hasattr(UVLPythonLexer, 'NEWLINE_sempred')
+
+# A private DFA cache for the patched lexers. ANTLR shares UVLPythonLexer.decisionsToDFA across
+# all lexer instances; filling its start state there would leak into unpatched UVL lexers,
+# which would then use it on the first token and skip the predicate.
+_DECISIONS_TO_DFA = [DFA(state, index)
+                     for index, state in enumerate(UVLPythonLexer.atn.decisionToState)]
+
+
+class _StartStateCachingSimulator(LexerATNSimulator):
+
+    # Parameter names follow LexerATNSimulator (pylint: arguments-renamed otherwise).
+    # pylint: disable=redefined-builtin
+    def match(self, input: InputStream, mode: int) -> int:
+        if self.line == 1 and self.column == 0:
+            # The only position where atStartOfInput() holds: neither read nor fill the cache.
+            self.mode = mode
+            mark = input.mark()
+            try:
+                self.startIndex = input.index
+                self.prevAccept.reset()
+                return int(self.execATN(input, self._start_state(input)))
+            finally:
+                input.release(mark)
+        return int(super().match(input, mode))
+
+    def matchATN(self, input: InputStream) -> int:
+        # Past the first token the predicate is false, so the start state is safe to cache.
+        start = self._start_state(input)
+        self.decisionToDFA[self.mode].s0 = start
+        return int(self.execATN(input, start))
+
+    def _start_state(self, input: InputStream) -> Any:
+        closure = self.computeStartState(input, self.atn.modeToStartState[self.mode])
+        closure.hasSemanticContext = False
+        return self.addDFAState(closure)
+
+
+def uvl_lexer(input_stream: InputStream) -> UVLCustomLexer:
+    """A UVL lexer, with the start-state cache workaround when the installed parser needs it."""
+    lexer = UVLCustomLexer(input_stream)
+    if NEEDS_WORKAROUND:
+        lexer._interp = _StartStateCachingSimulator(  # pylint: disable=protected-access
+            lexer, lexer.atn, _DECISIONS_TO_DFA, PredictionContextCache())
+    return lexer

{flamapy_fm-2.6.0.dev11 → flamapy_fm-2.9.0.dev0}/flamapy/metamodels/fm_metamodel/transformations/afm_reader.py

@@ -1,9 +1,10 @@
 import os
 
-from typing import Optional
+from typing import Any, Optional
 
-from afmparser import AFMParser
-from afmparser import get_tree
+from antlr4 import CommonTokenStream, FileStream
+from antlr4.error.ErrorListener import ErrorListener
+from afmparser import AFMLexer, AFMParser
 
 from flamapy.core.exceptions import FlamaException
 from flamapy.core.transformations import TextToModel
@@ -19,7 +20,32 @@ from flamapy.metamodels.fm_metamodel.models import (
 )
 
 
+class _RaisingErrorListener(ErrorListener):
+    """Turn syntax errors into exceptions: the generated parser recovers from them and the
+    reader would otherwise fail later on a half-built parse tree."""
+
+    def syntaxError(  # noqa: PLR0913, PLR0917 (ANTLR's signature)
+        self, recognizer: Any, offendingSymbol: Any, line: int, column: int, msg: str, e: Any
+    ) -> None:
+        raise FlamaException(f"AFM syntax error at line {line}:{column}: {msg}")
+
+
+def get_tree(path: str) -> AFMParser.Feature_modelContext:
+    """Parse an AFM file (UTF-8), raising FlamaException on the first syntax error."""
+    lexer = AFMLexer(FileStream(path, encoding="utf-8"))
+    lexer.removeErrorListeners()
+    lexer.addErrorListener(_RaisingErrorListener())
+    parser = AFMParser(CommonTokenStream(lexer))
+    parser.removeErrorListeners()
+    parser.addErrorListener(_RaisingErrorListener())
+    return parser.feature_model()
+
+
 class AFMReader(TextToModel):
+    """Read the AFM text format of FaMa. Relationships, attributes (Integer ranges and
+    discrete domains) and the logical constraints are read; constraints with relational or
+    arithmetic operators are not supported."""
+
     @staticmethod
     def get_source_extension() -> str:
         return "afm"
@@ -141,7 +167,8 @@ class AFMReader(TextToModel):
         if range_domain_node is not None:
             range_list = []
             for domain_range in range_domain_node.domain_range():
-                range_list.append(Range(domain_range.INT()[0], domain_range.INT()[1]))
+                range_list.append(Range(int(domain_range.INT()[0].getText()),
+                                        int(domain_range.INT()[1].getText())))
             domain = Domain(range_list, None)
 
         default_value = attribute_spec.attribute_default_value().value_spec().getText()
@@ -203,6 +230,7 @@ class AFMReader(TextToModel):
             "OR": ASTOperation.OR,
             "AND": ASTOperation.AND,
             "IFF": ASTOperation.EQUIVALENCE,
+            "IMPLIES": ASTOperation.IMPLIES,
         }
 
         if expression.__class__ in binary_operation_types:
@@ -219,8 +247,10 @@ class AFMReader(TextToModel):
             result.right = self.build_ast_node(expression.expression()[1], prefix)
 
         if isinstance(expression, AFMParser.NotExpContext):
+            # the operand of a unary operator is the left child (as the other readers and
+            # the AST simplification expect)
             result = Node(ASTOperation.NOT)
-            result.right = self.build_ast_node(expression.expression(), prefix)
+            result.left = self.build_ast_node(expression.expression(), prefix)
 
         if isinstance(expression, AFMParser.ParenthesisExpContext):
             result = self.build_ast_node(expression.expression(), prefix)