flamapy-fw 2.5.0.dev0__tar.gz → 2.6.0__tar.gz

flamapy_fw-2.6.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: flamapy-fw
+Version: 2.6.0
+Summary: Flamapy is a Python-based AAFM framework that takes into consideration previous AAFM tool designs and enables multi-solver and multi-metamodel support for the integration of AAFM tooling on the Python ecosystem.
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/core
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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"
+Dynamic: license-file
+
+# flamapy-fw
+
+The core framework of [flamapy](https://flamapy.org): the plugin-discovery
+mechanism and the base classes (operations, transformations, variability models)
+that every flamapy metamodel plugin builds on. It contains no analysis logic by
+itself.
+
+**Documentation:** https://docs.flamapy.org/framework
+
+## Installation
+
+```bash
+pip install flamapy-fw
+```

flamapy_fw-2.6.0/README.md

@@ -0,0 +1,14 @@
+# flamapy-fw
+
+The core framework of [flamapy](https://flamapy.org): the plugin-discovery
+mechanism and the base classes (operations, transformations, variability models)
+that every flamapy metamodel plugin builds on. It contains no analysis logic by
+itself.
+
+**Documentation:** https://docs.flamapy.org/framework
+
+## Installation
+
+```bash
+pip install flamapy-fw
+```

{flamapy_fw-2.5.0.dev0 → flamapy_fw-2.6.0}/flamapy/core/discover.py

@@ -11,10 +11,12 @@ from flamapy.core.exceptions import TransformationNotFound
 from flamapy.core.exceptions import ConfigurationNotFound
 from flamapy.core.models import VariabilityModel
 from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor, collect_descriptors
 from flamapy.core.plugins import Operations, Plugin, Plugins
 from flamapy.core.transformations import Transformation
 from flamapy.core.transformations.text_to_model import TextToModel
 from flamapy.core.transformations.model_to_model import ModelToModel
+from flamapy.core.utils import filename_matches_extension
 from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
 
 
@@ -103,6 +105,13 @@ class DiscoverMetamodels:
 
         return operations
 
+    def available_operations(self) -> dict[str, OperationDescriptor]:
+        """Facade descriptors of every discovered operation that declares one, keyed by public name.
+
+        This is the single source the facade, CLI and REST derive their operation surface from.
+        """
+        return collect_descriptors(self.get_operations())
+
     def get_transformations(self) -> list[Type[Transformation]]:
         """Get transformations for all modules"""
         transformations: list[Type[Transformation]] = []
@@ -256,14 +265,15 @@ class DiscoverMetamodels:
 
     def __transform_to_model_from_file(self, file: str) -> VariabilityModel:
         t2m_transformations = self.get_transformations_t2m()
-        extension = file.rsplit(".", maxsplit=1)[-1]
-        t2m_filters = filter(
-            lambda t2m: t2m.get_source_extension() == extension, t2m_transformations
-        )
-
-        t2m = next(t2m_filters, None)
-        if t2m is None:
+        # Prefer the most specific matching extension (e.g. 'uvl.json' over 'json').
+        candidates = [
+            t2m
+            for t2m in t2m_transformations
+            if filename_matches_extension(file, t2m.get_source_extension())
+        ]
+        if not candidates:
             raise TransformationNotFound()
+        t2m = max(candidates, key=lambda t: len(t.get_source_extension()))
 
         return t2m(file).transform()
 

flamapy_fw-2.6.0/flamapy/core/models/__init__.py

@@ -0,0 +1,4 @@
+from .variability_model import VariabilityModel, VariabilityElement  # pylint: disable=cyclic-import
+from .ast import AST, ASTOperation, NodeType  # pylint: disable=cyclic-import
+
+__all__ = ["AST", "ASTOperation", "NodeType", "VariabilityElement", "VariabilityModel"]

{flamapy_fw-2.5.0.dev0 → flamapy_fw-2.6.0}/flamapy/core/models/ast.py

@@ -1,6 +1,8 @@
-from typing import Any
+from typing import Any, Optional
 from enum import Enum
 
+from flamapy.core.exceptions import FlamaException
+
 
 class ASTOperation(Enum):
     # logical operators
@@ -69,11 +71,25 @@ AGGREGATION_OPERATORS = [
 ]
 
 
+class NodeType(Enum):
+    """Semantic type of a leaf node in the AST."""
+    FEATURE = "Feature"
+    LITERAL = "Literal"
+    OPERATOR = "Operator"
+
+
 class Node:
-    def __init__(self, data: Any, left: "Node" = None, right: "Node" = None):  # type: ignore
+    def __init__(
+        self,
+        data: Any,
+        left: "Node" = None,  # type: ignore[assignment]
+        right: "Node" = None,  # type: ignore[assignment]
+        node_type: Optional[NodeType] = None,
+    ):
         self.data = data
         self.left = left
         self.right = right
+        self.node_type = node_type
 
     def is_term(self) -> bool:
         return not self.is_op()
@@ -93,6 +109,19 @@ class Node:
     def is_aggregate_op(self) -> bool:
         return self.is_op() and self.data in AGGREGATION_OPERATORS
 
+    def is_feature(self) -> bool:
+        """Return True if this node is explicitly marked as a feature reference."""
+        return self.node_type == NodeType.FEATURE
+
+    def is_literal(self) -> bool:
+        """Return True if this node is a literal value (not a feature reference).
+
+        Falls back to a type-based check for nodes without an explicit node_type.
+        """
+        if self.node_type is not None:
+            return self.node_type == NodeType.LITERAL
+        return isinstance(self.data, (int, float))
+
     def __str__(self) -> str:
         data = self.data.value if self.is_op() else str(self.data)
         if self.left and self.right:
@@ -160,10 +189,31 @@ class AST:
     def to_cnf(self) -> "AST":
         return convert_into_cnf(self)
 
-    def get_clauses(self) -> list[list[Any]]:
+    def get_clauses(self, method: str = 'distributive') -> list[list[Any]]:
+        """Return the CNF clauses of this AST.
+
+        ``method='distributive'`` (default) uses the classic distributive expansion and
+        returns clauses over the formula's own variables. ``method='tseytin'`` uses the
+        Tseytin transformation; the returned clauses may contain fresh auxiliary
+        variables. Use :meth:`get_clauses_with_aux` when those auxiliary variable names
+        are needed (e.g. to register them as non-feature solver variables).
+        """
+        if method == 'tseytin':
+            clauses, _ = tseytin_cnf(self)
+            return clauses
         ast = self.to_cnf()
         return get_clauses(ast)
 
+    def get_clauses_with_aux(self, method: str = 'tseytin') -> tuple[list[list[Any]], list[str]]:
+        """Return ``(clauses, aux_names)`` for the given CNF ``method``.
+
+        For ``'tseytin'`` this exposes the auxiliary variable names introduced by the
+        encoding. For ``'distributive'`` the auxiliary list is always empty.
+        """
+        if method == 'tseytin':
+            return tseytin_cnf(self)
+        return get_clauses(self.to_cnf()), []
+
     def get_operators(self) -> list[ASTOperation]:
         operators = []
         stack = [self.root]
@@ -236,20 +286,22 @@ def simplify_formula(ast: AST) -> AST:
         )
     elif logic_op == ASTOperation.EQUIVALENCE:
         # Replace P <=> Q with P => Q ∧ Q => P.
-        left = simplify_formula(AST.create_binary_operation(ASTOperation.IMPLIES, left, right)).root
-        right = simplify_formula(
+        new_left = simplify_formula(
+            AST.create_binary_operation(ASTOperation.IMPLIES, left, right)
+        ).root
+        new_right = simplify_formula(
             AST.create_binary_operation(ASTOperation.IMPLIES, right, left)
         ).root
-        result = AST.create_binary_operation(ASTOperation.AND, left, right)
+        result = AST.create_binary_operation(ASTOperation.AND, new_left, new_right)
     elif logic_op == ASTOperation.XOR:
         # Replace P XOR Q with (P ∧ !Q) v (!P ∧ Q).
-        left = simplify_formula(
+        new_left = simplify_formula(
             AST.create_binary_operation(ASTOperation.AND, left, Node(ASTOperation.NOT, right))
         ).root
-        left = simplify_formula(
+        new_right = simplify_formula(
             AST.create_binary_operation(ASTOperation.AND, Node(ASTOperation.NOT, left), right)
         ).root
-        result = AST.create_binary_operation(ASTOperation.OR, left, right)
+        result = AST.create_binary_operation(ASTOperation.OR, new_left, new_right)
     elif logic_op == ASTOperation.AND:
         left = simplify_formula(AST(left)).root
         right = simplify_formula(AST(right)).root
@@ -349,6 +401,85 @@ def propagate_negation(node: Node, negated: bool = False) -> AST:
     return result
 
 
+TSEYTIN_AUX_PREFIX = "__tseytin_"
+
+
+def _negate_literal(literal: Any) -> Any:
+    """Flip the sign of a CNF literal that uses the ``"-name"`` string convention."""
+    if isinstance(literal, str) and literal.startswith("-"):
+        return literal[1:]
+    return "-" + str(literal)
+
+
+def _tseytin_gate_clauses(op: ASTOperation, gate: Any, a: Any, b: Any) -> list[list[Any]]:
+    """Biconditional clauses encoding ``gate <=> (a op b)`` for a binary logical ``op``.
+
+    ``a`` and ``b`` are literals; ``gate`` is the fresh auxiliary literal. Encoding each
+    connective directly (rather than expanding it first) is what keeps the transformation
+    linear in the formula size.
+    """
+    g, na, nb, ng = gate, _negate_literal(a), _negate_literal(b), _negate_literal(gate)
+    if op == ASTOperation.AND:
+        return [[ng, a], [ng, b], [g, na, nb]]
+    if op == ASTOperation.OR:
+        return [[g, na], [g, nb], [ng, a, b]]
+    if op in (ASTOperation.IMPLIES, ASTOperation.REQUIRES):  # a -> b  ==  (not a) or b
+        return [[g, a], [g, nb], [ng, na, b]]
+    if op == ASTOperation.EXCLUDES:  # (not a) or (not b)
+        return [[g, a], [g, b], [ng, na, nb]]
+    if op == ASTOperation.EQUIVALENCE:  # a <-> b
+        return [[ng, na, b], [ng, a, nb], [g, a, b], [g, na, nb]]
+    if op == ASTOperation.XOR:  # a xor b
+        return [[ng, a, b], [ng, na, nb], [g, na, b], [g, a, nb]]
+    raise FlamaException(
+        f"Operation '{op}' is not a propositional connective supported by the Tseytin "
+        f"transformation."
+    )
+
+
+def tseytin_cnf(ast: AST) -> tuple[list[list[Any]], list[str]]:
+    """Return an equisatisfiable CNF of ``ast`` using the Tseytin transformation.
+
+    Unlike the distributive :func:`to_cnf`, this produces a CNF whose size is linear
+    in the size of the formula by introducing one fresh auxiliary variable per gate.
+    Each logical connective is encoded directly (no distributive expansion), so formulas
+    that blow up under :func:`to_cnf` (XOR chains, wide equivalences) stay compact. Gates
+    are encoded as full biconditionals (``g <=> subformula``) so that every model of the
+    original formula extends to exactly one model of the encoding; this preserves model
+    counts and configuration enumeration (once auxiliary variables are projected out).
+
+    Returns a tuple ``(clauses, aux_names)`` where ``clauses`` is a list of clauses
+    (each a list of literals in the same ``"-name"`` string convention as
+    :func:`get_clauses`) and ``aux_names`` lists every auxiliary variable name
+    introduced (each prefixed with :data:`TSEYTIN_AUX_PREFIX`) so callers can register
+    them as solver variables that are not features.
+
+    Raises :class:`FlamaException` if the formula contains a non-propositional operator
+    (arithmetic, comparison or aggregation).
+    """
+    clauses: list[list[Any]] = []
+    aux_names: list[str] = []
+    counter = [0]
+
+    def literal_of(node: Node) -> Any:
+        if node.is_term():
+            return node.data
+        if node.data == ASTOperation.NOT:
+            # Negation of a single literal is free; no gate needed.
+            return _negate_literal(literal_of(node.left))
+        left_lit = literal_of(node.left)
+        right_lit = literal_of(node.right)
+        counter[0] += 1
+        gate = f"{TSEYTIN_AUX_PREFIX}{counter[0]}"
+        aux_names.append(gate)
+        clauses.extend(_tseytin_gate_clauses(node.data, gate, left_lit, right_lit))
+        return gate
+
+    root_literal = literal_of(ast.root)
+    clauses.append([root_literal])  # assert the whole formula is true
+    return clauses, aux_names
+
+
 def get_clauses(ast: AST) -> list[list[Any]]:
     """Return the list of clauses represented by the AST root node in conjunctive normal form."""
     node = ast.root

{flamapy_fw-2.5.0.dev0 → flamapy_fw-2.6.0}/flamapy/core/operations/__init__.py

@@ -17,9 +17,15 @@ from .variability import Variability  # pylint: disable=cyclic-import
 from .sampling import Sampling  # pylint: disable=cyclic-import
 from .atomic_sets import AtomicSets  # pylint: disable=cyclic-import
 from .metrics_operation import Metrics  # pylint: disable=cyclic-import
+from .attribute_optimization import (  # pylint: disable=cyclic-import
+    AttributeOptimization,
+    OptimizationGoal,
+)
+from .descriptor import Input, OperationDescriptor, collect_descriptors
 
 __all__ = [
     "AtomicSets",
+    "AttributeOptimization",
     "AverageBranchingFactor",
     "Commonality",
     "Configurations",
@@ -32,10 +38,14 @@ __all__ = [
     "EstimatedConfigurationsNumber",
     "FalseOptionalFeatures",
     "Filter",
+    "Input",
     "Metrics",
     "Operation",
+    "OperationDescriptor",
+    "OptimizationGoal",
     "Sampling",
     "Satisfiable",
     "SatisfiableConfiguration",
     "Variability",
+    "collect_descriptors",
 ]

flamapy_fw-2.6.0/flamapy/core/operations/attribute_optimization.py

@@ -0,0 +1,68 @@
+from abc import abstractmethod
+from enum import Enum
+from typing import Any
+
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor, Input
+
+
+class OptimizationGoal(Enum):
+    MAXIMIZE = 'Maximize'
+    MINIMIZE = 'Minimize'
+
+
+def _attribute_optimization_inputs(operation: Any, facade: Any, kwargs: dict[str, Any]) -> None:
+    objectives = kwargs['objectives']
+    if isinstance(objectives, str):
+        attributes = {objectives: OptimizationGoal.MINIMIZE}
+    else:
+        attributes = {
+            name: (OptimizationGoal.MINIMIZE if str(goal).lower().startswith('min')
+                   else OptimizationGoal.MAXIMIZE)
+            for name, goal in dict(objectives).items()
+        }
+    operation.set_attributes(attributes)
+
+
+def _attribute_optimization_result(result: Any) -> Any:
+    # z3 returns (configuration, values) tuples; sat returns bare configurations.
+    return [item[0] if isinstance(item, tuple) else item for item in result]
+
+
+class AttributeOptimization(Operation):
+    """Return the configuration(s) that optimize the given numeric feature attribute(s).
+
+    Attributes are identified by name and mapped to an :class:`OptimizationGoal`. The
+    objective for each attribute is the sum of its values over the selected features.
+    """
+
+    facade = OperationDescriptor(
+        doc=(
+            'Returns the configuration(s) that optimize one or more numeric feature\n'
+            'attributes.\n'
+            '\n'
+            '``objectives`` is either a single attribute name (defaults to minimizing it)\n'
+            'or a mapping ``{attribute_name: "Minimize"|"Maximize"}``. ``backend`` selects\n'
+            'the plugin: "sat" performs single-objective MaxSAT optimization; "z3"\n'
+            'additionally supports typed attributes and multi-objective (Pareto)\n'
+            'optimization. Defaults to "sat".'
+        ),
+        returns='Union[None, List[Configuration]]',
+        name='attribute_optimization', operation='AttributeOptimization', default_backend='sat',
+        selectable_backend=True,
+        inputs=(Input('objectives', Any, required=True),),
+        input_adapter=_attribute_optimization_inputs,
+        result_adapter=_attribute_optimization_result,
+    )
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def set_attributes(self, attributes: dict[str, OptimizationGoal]) -> None:
+        """Set the attributes to optimize as a mapping ``{attribute_name: OptimizationGoal}``."""
+
+    @abstractmethod
+    def optimize(self) -> list[Any]:
+        """Return the optimal configuration(s)."""

flamapy_fw-2.6.0/flamapy/core/operations/configurations.py

@@ -0,0 +1,29 @@
+from abc import abstractmethod
+
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+
+
+class Configurations(Operation):
+    facade = OperationDescriptor(
+        doc=(
+            'These are the individual outcomes that can be produced from a feature model.\n'
+            'Each product is a combination of features that satisfies all the constraints\n'
+            'and dependencies in the feature model.\n'
+            '\n'
+            '``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to\n'
+            'bdd.'
+        ),
+        returns='Union[None, List[Configuration]]',
+        name='configurations', operation='Configurations', default_backend='bdd',
+        selectable_backend=True,
+    )
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def get_configurations(self) -> list[Configuration]:
+        pass

flamapy_fw-2.6.0/flamapy/core/operations/configurations_number.py

@@ -0,0 +1,30 @@
+from abc import abstractmethod
+
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor
+
+
+class ConfigurationsNumber(Operation):
+    facade = OperationDescriptor(
+        doc=(
+            'This is the total number of different full configurations that can be produced\n'
+            "from a feature model. It's calculated by considering all possible combinations\n"
+            'of features, taking into account the constraints and dependencies between\n'
+            'features.\n'
+            '\n'
+            '``backend`` selects the analysis plugin ("sat", "bdd", "z3", or "sharpsat" for\n'
+            'a scalable approximate count via the optional flamapy-sharpsat plugin);\n'
+            'defaults to bdd.'
+        ),
+        returns='Union[None, int]',
+        name='configurations_number', operation='ConfigurationsNumber', default_backend='bdd',
+        selectable_backend=True,
+    )
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def get_configurations_number(self) -> int:
+        pass

flamapy_fw-2.6.0/flamapy/core/operations/core_features.py

@@ -0,0 +1,29 @@
+from abc import abstractmethod
+
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor
+from flamapy.core.models.variability_model import VariabilityElement
+
+
+class CoreFeatures(Operation):
+    facade = OperationDescriptor(
+        doc=(
+            'These are the features that are present in all products of a product line. In\n'
+            'a feature model, they are the features that are mandatory and not optional.\n'
+            'Core features define the commonality among all products in a product line.\n'
+            '\n'
+            '``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to\n'
+            'sat.'
+        ),
+        returns='Union[None, List[str]]',
+        name='core_features', operation='CoreFeatures', default_backend='sat',
+        selectable_backend=True,
+    )
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def get_core_features(self) -> list[VariabilityElement]:
+        pass

flamapy_fw-2.6.0/flamapy/core/operations/dead_features.py

@@ -0,0 +1,29 @@
+from abc import abstractmethod
+
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor
+from flamapy.core.models.variability_model import VariabilityElement
+
+
+class DeadFeatures(Operation):
+    facade = OperationDescriptor(
+        doc=(
+            'These are features that, due to the constraints and dependencies in the\n'
+            'feature model, cannot be included in any valid product. Dead features are\n'
+            'usually a sign of an error in the feature model.\n'
+            '\n'
+            '``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to\n'
+            'sat.'
+        ),
+        returns='Union[None, List[str]]',
+        name='dead_features', operation='DeadFeatures', default_backend='sat',
+        selectable_backend=True,
+    )
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def get_dead_features(self) -> list[VariabilityElement]:
+        pass

flamapy_fw-2.6.0/flamapy/core/operations/descriptor.py

@@ -0,0 +1,61 @@
+"""Self-describing metadata for operations, so the facade/CLI/REST can be *derived* from the
+installed operations instead of hand-written.
+
+An operation interface (or a bespoke concrete operation) declares a class attribute ``facade`` of
+type :class:`OperationDescriptor`. It states the operation's stable public name, which backend it
+runs on, its inputs (and how to wire them), and optional input/result adapters for the few
+operations whose facade method is not a plain ``set params -> execute``. Concrete backend
+implementations inherit the descriptor from their interface, so there is exactly one descriptor
+per *logical* operation.
+"""
+from dataclasses import dataclass
+from typing import Any, Callable, Iterable, Optional
+
+
+@dataclass(frozen=True)
+class Input:
+    """One input of a facade operation and how to feed it to the underlying operation."""
+
+    name: str
+    type: Any = str                   # a type or typing special form (e.g. Any), for CLI/REST
+    default: Any = None
+    required: bool = False
+    setter: Optional[str] = None      # operation setter for the value, e.g. 'set_sample_size'
+    kind: str = 'scalar'              # 'scalar' | 'configuration' | 'file' (CLI/REST marshalling)
+
+
+@dataclass(frozen=True)
+class OperationDescriptor:
+    """Everything the facade/CLI/REST need to expose an operation without hand-written code."""
+
+    name: str                                     # stable public (facade/CLI/REST) name
+    operation: str                                # name passed to DiscoverMetamodels.use_operation
+    kind: str = 'operation'                       # 'operation' | 'producer' | 'transformer'
+    default_backend: Optional[str] = None         # None => runs directly on the feature model
+    backends: Optional[tuple[str, ...]] = None    # allowed backends (None => any implementer)
+    selectable_backend: bool = False              # facade exposes a backend= kwarg (else fixed)
+    inputs: tuple[Input, ...] = ()
+    # For the ~12 non-uniform methods: custom wiring / result reshaping. When absent, the generic
+    # "call each Input.setter, then execute, then get_result" path is used.
+    input_adapter: Optional[Callable[..., Any]] = None
+    result_adapter: Optional[Callable[[Any], Any]] = None
+    doc: str = ''
+    returns: str = 'Any'                          # return annotation (source text) for the stub
+
+    @property
+    def needs_backend(self) -> bool:
+        return self.default_backend is not None
+
+
+def collect_descriptors(operations: Iterable[type]) -> dict[str, OperationDescriptor]:
+    """Collect the ``facade`` descriptors from a set of operation classes, keyed by public name.
+
+    Concrete backend operations inherit their interface's descriptor, so several classes may yield
+    the same descriptor; they are de-duplicated by ``descriptor.name`` (first one wins).
+    """
+    descriptors: dict[str, OperationDescriptor] = {}
+    for operation in operations:
+        descriptor = getattr(operation, 'facade', None)
+        if isinstance(descriptor, OperationDescriptor):
+            descriptors.setdefault(descriptor.name, descriptor)
+    return descriptors

flamapy_fw-2.6.0/flamapy/core/operations/false_optional_features.py

@@ -0,0 +1,33 @@
+from abc import abstractmethod
+
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor
+from flamapy.core.models.variability_model import VariabilityElement
+
+
+class FalseOptionalFeatures(Operation):
+    """A feature is defined as `false optional` if the selection of its parent makes the feature
+    itself selected as well, although it is defined as optional and not mandatory.
+
+    A feature in a group can be also `false optional`.
+    In general, false optional features should be marked as mandatory for maintainability purposes.
+    """
+
+    facade = OperationDescriptor(
+        doc=(
+            'These are features that appear to be optional in the feature model, but due to\n'
+            'the constraints and dependencies, must be included in every valid product.\n'
+            'Like dead features, false optional features are usually a sign of an error in\n'
+            'the feature model.\n'
+            '\n'
+            '``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to\n'
+            'sat.'
+        ),
+        returns='Union[None, List[str]]',
+        name='false_optional_features', operation='FalseOptionalFeatures', default_backend='sat',
+        selectable_backend=True,
+    )
+
+    @abstractmethod
+    def get_false_optional_features(self) -> list[VariabilityElement]:
+        pass

{flamapy_fw-2.5.0.dev0 → flamapy_fw-2.6.0}/flamapy/core/operations/metrics_operation.py

@@ -19,10 +19,10 @@ class Metrics(Operation, metaclass=ABCMeta):
     """
 
     filter: Optional[list[str]] = None
-    result: list[dict[str, Any]] = []
 
     def __init__(self) -> None:
         self.model: Optional[VariabilityModel] = None
+        self.result: list[dict[str, Any]] = []
 
     @abstractmethod
     def calculate_metamodel_metrics(self, model: VariabilityModel) -> list[dict[str, Any]]:

{flamapy_fw-2.5.0.dev0 → flamapy_fw-2.6.0}/flamapy/core/operations/sampling.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 
 from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
 from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor, Input
 
 
 class Sampling(Operation):
@@ -9,6 +10,24 @@ class Sampling(Operation):
     (or configurations) from within a variability model.
     """
 
+    facade = OperationDescriptor(
+        doc=(
+            'Returns a random sample of valid configurations of the given size. When\n'
+            'with_replacement is True, the same configuration may appear more than once.\n'
+            '\n'
+            '``backend`` selects the analysis plugin; defaults to bdd. sat and bdd\n'
+            'implement (deterministic/enumerating) sampling; "sharpsat" provides almost-\n'
+            'uniform sampling via the optional flamapy-sharpsat plugin.'
+        ),
+        returns='Union[None, List[Configuration]]',
+        name='sampling', operation='Sampling', default_backend='bdd',
+        selectable_backend=True,
+        inputs=(
+            Input('size', int, required=True, setter='set_sample_size'),
+            Input('with_replacement', bool, default=False, setter='set_with_replacement'),
+        ),
+    )
+
     @abstractmethod
     def __init__(self) -> None:
         pass