flamapy 2.6.0.dev4__py3-none-any.whl → 2.6.0.dev11__py3-none-any.whl

flamapy/commands/__init__.py

@@ -1,11 +1,13 @@
 import argparse
 import os
+import shutil
 import sys
+import textwrap
 from functools import wraps
 import inspect
 from pathlib import Path
 from shutil import copytree
-from typing import Any, List, Tuple, Optional
+from typing import Any, List, Tuple, Optional, Union, get_args, get_origin
 from types import FunctionType
 
 from flamapy.interfaces.python.flamapy_feature_model import FLAMAFeatureModel
@@ -13,6 +15,26 @@ from flamapy.interfaces.python.flamapy_feature_model import FLAMAFeatureModel
 # List to store registered commands and their arguments
 MANUAL_COMMANDS: List[Tuple[str, str, FunctionType, Tuple[Any, ...]]] = []
 
+# Section headings for the no-args listing, keyed by the operations' default backend
+# (None => the operation runs directly on the feature model tree). Backends not listed
+# here (future plugins) get their own section headed by the backend name.
+BACKEND_SECTIONS: List[Tuple[Optional[str], str]] = [
+    (None, "Feature model operations (no solver required)"),
+    ("sat", "SAT-based operations (pysat metamodel)"),
+    ("bdd", "BDD-based operations (bdd metamodel)"),
+    ("z3", "SMT-based operations (z3 metamodel)"),
+    ("pysat_diagnosis", "Diagnosis operations (pysat_diagnosis metamodel)"),
+]
+
+
+def _summary(doc: str) -> str:
+    """One-line summary of a docstring: whitespace collapsed, first sentence only."""
+    collapsed = " ".join(doc.split())
+    if not collapsed:
+        return "(no description)"
+    end = collapsed.find(". ")
+    return collapsed[: end + 1] if end != -1 else collapsed
+
 
 def command(name, description, *args):  # type: ignore
     def decorator(func):  # type: ignore
@@ -27,26 +49,30 @@ def command(name, description, *args):  # type: ignore
     return decorator
 
 
-def extract_commands(cls: type) -> List[Tuple[str, str, FunctionType, List[inspect.Parameter]]]:
+def extract_commands(
+    cls: type,
+) -> List[Tuple[str, str, FunctionType, List[inspect.Parameter], Any]]:
     commands = []
     for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
         if name.startswith("_"):
             continue
+        if getattr(method, "_facade_kind", "operation") != "operation":
+            continue  # producers/transformers return models; Python-API only for now
         docstring: Optional[str] = method.__doc__
         signature = inspect.signature(method)
         # Exclude 'self' from parameters
         parameters = list(signature.parameters.values())[1:]  # Skip 'self'
-        commands.append((name, docstring or "", method, parameters))
+        descriptor = getattr(method, "_facade_descriptor", None)
+        commands.append((name, docstring or "", method, parameters, descriptor))
     return commands
 
 
 @command(
     "generate_plugin",
-    """This command generates a new plugin to implement your
-         cusom operations. To execute it you should set yourself in the path of the
-         flamapy src directory""",
-    ("name", str, "The pluggins name"),
-    ("extension", str, "The extansion to be registered with the flamapy ecosystem"),
+    "Generates a new plugin skeleton to implement your custom operations. "
+    "Run it from the path of the flamapy src directory.",
+    ("name", str, "The plugin's name"),
+    ("extension", str, "The extension to be registered with the flamapy ecosystem"),
     ("path", str, "The path to generate it"),
 )
 def generate_plugin(args):  # type: ignore
@@ -92,37 +118,50 @@ def generate_plugin(args):  # type: ignore
     print("Plugin generated!")
 
 
+def resolve_annotation_type(annotation: Any) -> type:
+    """Map a parameter annotation to a concrete type usable as an argparse 'type'.
+
+    Unwraps Optional[X]/Union[X, None] to X; falls back to str for anything
+    that is not a plain class (argparse requires a callable).
+    """
+    if annotation is inspect.Parameter.empty:
+        return str
+    if get_origin(annotation) is Union:
+        args = [arg for arg in get_args(annotation) if arg is not type(None)]
+        annotation = args[0] if args else str
+    return annotation if isinstance(annotation, type) else str
+
+
 def setup_dynamic_commands(subparsers, dynamic_commands):  # type: ignore
-    for name, docstring, method, parameters in dynamic_commands:
-        subparser = subparsers.add_parser(name, help=docstring)
+    for name, docstring, method, parameters, _ in dynamic_commands:
+        subparser = subparsers.add_parser(name, help=_summary(docstring), description=docstring)
         subparser.add_argument("model_path", type=str, help="Path to the feature model file")
-        if "configuration_path" in [param.name for param in parameters]:
-            subparser.add_argument(
-                "--configuration_path",
-                type=str,
-                help="Path to the configuration file",
-                required=False,
-            )
         for param in parameters:
             arg_name = param.name
             if arg_name not in ["model_path"]:  # Avoid duplicates
+                arg_type = resolve_annotation_type(param.annotation)
                 if param.default == param.empty:  # Positional argument
+                    subparser.add_argument(arg_name, type=arg_type, help=arg_type.__name__)
+                elif arg_type is bool:  # Boolean flag (type=bool would parse 'False' as True)
                     subparser.add_argument(
-                        arg_name, type=param.annotation, help=param.annotation.__name__
+                        f"--{arg_name}",
+                        action=argparse.BooleanOptionalAction,
+                        default=param.default,
+                        help="Optional bool",
                     )
                 else:  # Optional argument
                     subparser.add_argument(
                         f"--{arg_name}",
-                        type=param.annotation,
+                        type=arg_type,
                         default=param.default,
-                        help=f"Optional {param.annotation.__name__}",
+                        help=f"Optional {arg_type.__name__}",
                     )
         subparser.set_defaults(func=method, method_name=name, parameters=parameters)
 
 
 def setup_manual_commands(subparsers, manual_commands):  # type: ignore
     for name, description, func, args in manual_commands:
-        subparser = subparsers.add_parser(name, help=description)
+        subparser = subparsers.add_parser(name, help=_summary(description), description=description)
         for arg in args:
             arg_name, arg_type, arg_help = arg
             subparser.add_argument(arg_name, type=arg_type, help=arg_help)
@@ -157,9 +196,51 @@ def execute_command(args: argparse.Namespace) -> None:
         print(f"Attribute error: {attr_error}")
 
 
+def _print_section(title: str, rows: List[Tuple[str, str]], column: int, width: int) -> None:
+    print(f"{title}:")
+    for label, summary in sorted(rows):
+        lead = f"  {label:<{column}}  "
+        wrapped = textwrap.wrap(summary, width=max(width - len(lead), 20)) or [""]
+        print(lead + wrapped[0])
+        for line in wrapped[1:]:
+            print(" " * len(lead) + line)
+
+
+def print_command_overview(dynamic_commands) -> None:  # type: ignore
+    width = min(shutil.get_terminal_size().columns, 100)
+    rows_by_backend: dict[Optional[str], List[Tuple[str, str]]] = {}
+    for name, docstring, _, _, descriptor in dynamic_commands:
+        backend = getattr(descriptor, "default_backend", None)
+        label = name + (" *" if getattr(descriptor, "selectable_backend", False) else "")
+        rows_by_backend.setdefault(backend, []).append((label, _summary(docstring)))
+    manual_rows = [(name, _summary(description)) for name, description, _, _ in MANUAL_COMMANDS]
+
+    all_rows = [row for rows in rows_by_backend.values() for row in rows] + manual_rows
+    column = max((len(label) for label, _ in all_rows), default=0)
+
+    sections = list(BACKEND_SECTIONS)
+    known = {backend for backend, _ in sections}
+    sections += [(backend, f"Operations on the {backend} backend")
+                 for backend in sorted(rows_by_backend.keys() - known, key=str)]
+    first = True
+    for backend, title in sections:
+        rows = rows_by_backend.get(backend)
+        if not rows:
+            continue
+        if not first:
+            print()
+        _print_section(title, rows, column, width)
+        first = False
+    print()
+    _print_section("Framework developers operations", manual_rows, column, width)
+    print()
+    print("Operations marked with * accept a --backend option to pick the solver.")
+    print("Run 'flamapy <command> --help' for details, or 'flamapy --help' for the full list.")
+
+
 def flamapy_cli() -> None:
     parser = argparse.ArgumentParser(description="FLAMA Feature Model CLI")
-    subparsers = parser.add_subparsers(dest="command")
+    subparsers = parser.add_subparsers(dest="command", metavar="COMMAND", title="commands")
 
     dynamic_commands = extract_commands(FLAMAFeatureModel)
     setup_dynamic_commands(subparsers, dynamic_commands)
@@ -170,10 +251,4 @@ def flamapy_cli() -> None:
     if args.command:
         execute_command(args)
     else:
-        print("Feature model operations:")
-        for name, docstring, _, _ in dynamic_commands:
-            print(f"  {name}: {docstring}")
-        print("Framework developers operations:")
-        for name, description, _, _ in MANUAL_COMMANDS:
-            print(f"  {name}: {description}")
-        print("Execute flamapy --help for more information")
+        print_command_overview(dynamic_commands)

flamapy/interfaces/python/_stub.py

@@ -0,0 +1,76 @@
+"""Generator for ``flamapy_feature_model.pyi`` — static typing for the descriptor-generated facade.
+
+The facade synthesises its operation methods at runtime, so type checkers and IDEs cannot see them.
+This module renders a ``.pyi`` stub from the same OperationDescriptors, giving autocomplete and
+mypy the real signatures + return types. Run ``python -m flamapy.interfaces.python._stub`` to
+regenerate; a test asserts the shipped stub matches this output so it never drifts.
+"""
+from typing import Any
+
+from flamapy.core.discover import DiscoverMetamodels
+from flamapy.core.operations import Input, OperationDescriptor
+
+_HEADER = '''\
+# Auto-generated by flamapy.interfaces.python._stub — do not edit by hand.
+# Regenerate with: python -m flamapy.interfaces.python._stub
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from flamapy.metamodels.configuration_metamodel.models import Configuration
+from flamapy.metamodels.fm_metamodel.models import FeatureModel
+
+
+class Backend(str, Enum):
+    SAT = ...
+    BDD = ...
+    Z3 = ...
+    SHARPSAT = ...
+
+
+class FLAMAFeatureModel:
+    model_path: str
+    fm_model: FeatureModel
+    backend: Optional[Backend]
+    def __init__(self, model_path: str, backend: Optional[str] = ...) -> None: ...
+'''
+
+
+def _input_annotation(input_spec: Input) -> str:
+    base = 'Any' if input_spec.type is Any else getattr(input_spec.type, '__name__', 'Any')
+    if not input_spec.required and input_spec.default is None:
+        return f'Optional[{base}]'
+    return base
+
+
+def _method_signature(descriptor: OperationDescriptor) -> str:
+    params = [] if descriptor.kind == 'producer' else ['self']
+    for input_spec in descriptor.inputs:
+        annotation = _input_annotation(input_spec)
+        if input_spec.required:
+            params.append(f'{input_spec.name}: {annotation}')
+        else:
+            params.append(f'{input_spec.name}: {annotation} = ...')
+    if descriptor.selectable_backend:
+        params.append('backend: Optional[str] = ...')
+    return ', '.join(params)
+
+
+def render_stub(operations: 'dict[str, OperationDescriptor] | None' = None) -> str:
+    if operations is None:
+        operations = DiscoverMetamodels().available_operations()
+    lines = [_HEADER.rstrip('\n')]
+    for name in sorted(operations):
+        descriptor = operations[name]
+        if descriptor.kind == 'producer':
+            lines.append('    @staticmethod')
+        lines.append(
+            f'    def {name}({_method_signature(descriptor)}) -> {descriptor.returns}: ...')
+    return '\n'.join(lines) + '\n'
+
+
+if __name__ == '__main__':
+    import os
+    target = os.path.join(os.path.dirname(__file__), 'flamapy_feature_model.pyi')
+    with open(target, 'w', encoding='utf-8') as handle:
+        handle.write(render_stub())
+    print(f'wrote {target}')

flamapy/interfaces/python/flamapy_feature_model.py

@@ -1,716 +1,214 @@
+"""Descriptor-driven facade over the flamapy analysis operations.
+
+The public operation methods are not written by hand. At import time :func:`_install_operations`
+reads the :class:`OperationDescriptor`s discovered from the installed plugins
+(:meth:`DiscoverMetamodels.available_operations`) and synthesises one method per operation, each
+with a real signature and ``__doc__`` so the CLI and REST layers can keep introspecting the class.
+Dropping a new operation into a plugin therefore extends the Python facade, the CLI and the REST API
+for free. Backend resolution is dynamic (by fm-to-backend transformation extension), so there is no
+per-operation or per-backend code here. Static typing is provided by a generated ``.pyi`` stub.
+"""
+import inspect
 import logging
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, Optional, Union
+
 from flamapy.core.discover import DiscoverMetamodels
-from flamapy.core.models import VariabilityModel
-from flamapy.metamodels.fm_metamodel.models import FeatureModel
 from flamapy.core.exceptions import FlamaException
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import OperationDescriptor
 from flamapy.metamodels.configuration_metamodel.models import Configuration
+from flamapy.metamodels.fm_metamodel.models import FeatureModel
 
 logger = logging.getLogger(__name__)
 
 
 class Backend(str, Enum):
-    """Analysis backend (plugin) used to run a facade operation."""
+    """Analysis backend identifier.
+
+    Retained so the REST layer can offer a backend dropdown; the facade itself no longer switches on
+    it — it resolves the backend dynamically to a transformation extension.
+    """
 
     SAT = "sat"
     BDD = "bdd"
     Z3 = "z3"
+    SHARPSAT = "sharpsat"
+
+
+# Facade backend name -> fm-to-backend transformation extension (the only non-identity mapping).
+_BACKEND_ALIAS = {"sat": "pysat"}
 
 
 class FLAMAFeatureModel:
-    # Backend -> (lazy transformation method, attribute caching the model)
-    _BACKENDS = {
-        Backend.SAT: ("_transform_to_sat", "sat_model"),
-        Backend.BDD: ("_transform_to_bdd", "bdd_model"),
-        Backend.Z3: ("_transform_to_z3", "z3_model"),
-    }
-
-    def __init__(self, model_path: str, backend: Optional[str] = None):
-        """
-        This is the path in the filesystem where the model is located.
-        Any model in UVL, FaMaXML or FeatureIDE format are accepted.
+    """A feature model together with the analysis operations discovered from the installed plugins.
 
-        ``backend`` optionally sets a workspace-wide default backend
-        ("sat", "bdd" or "z3") for every operation that supports more than
-        one. When left as ``None`` each operation keeps its own historical
-        default, so existing code behaves exactly as before.
+    Operation methods are generated from their OperationDescriptors (see the module docstring); call
+    them as normal methods, e.g. ``FLAMAFeatureModel(path).satisfiable()``.
+    """
+
+    def __init__(self, model_path: str, backend: Optional[str] = None) -> None:
+        """``model_path`` is the filesystem path to the model (UVL, FaMaXML or FeatureIDE).
+
+        ``backend`` optionally sets a workspace-wide default backend ("sat", "bdd" or "z3") for
+        every operation that supports more than one. When left as ``None`` each operation keeps its
+        historical default, so existing code behaves exactly as before.
         """
         self.model_path = model_path
         self.discover_metamodel = DiscoverMetamodels()
         self.fm_model = self._read(model_path)
-        self.sat_model = None
-        self.bdd_model = None
-        self.z3_model = None
-        self.diagnosis_model = None
         self.backend = Backend(backend) if backend is not None else None
+        self._backend_models: Dict[str, VariabilityModel] = {}
 
     def _read(self, model_path: str) -> FeatureModel:
         return self.discover_metamodel.use_transformation_t2m(model_path, "fm")
 
-    def _select_backend(
-        self,
-        backend: Optional[str],
-        default: Backend,
-    ) -> VariabilityModel:
-        """Resolve the backend to use, lazily transform to it and return its model.
-
-        Resolution order: explicit per-call ``backend`` > workspace-wide
-        ``self.backend`` > the operation's historical ``default``. All
-        backends (sat, bdd, z3) are accepted; if the chosen one does not
-        implement the requested operation a FlamaException is raised when it
-        runs.
-        """
-        try:
-            chosen = Backend(backend) if backend is not None else (self.backend or default)
-        except ValueError:
-            raise FlamaException(
-                f"Unknown backend '{backend}'. "
-                f"Choose from {[b.value for b in Backend]}."
-            )
-        transform, attr = self._BACKENDS[chosen]
-        getattr(self, transform)()
-        return getattr(self, attr)
-
-    def _transform_to_sat(self) -> None:
-        if self.sat_model is None:
-            self.sat_model = self.discover_metamodel.use_transformation_m2m(self.fm_model, "pysat")
-
-    def _transform_to_bdd(self) -> None:
-        if self.bdd_model is None:
-            self.bdd_model = self.discover_metamodel.use_transformation_m2m(self.fm_model, "bdd")
-
-    def _transform_to_z3(self) -> None:
-        if self.z3_model is None:
-            self.z3_model = self.discover_metamodel.use_transformation_m2m(self.fm_model, "z3")
-
-    def _transform_to_diagnosis(self) -> None:
-        if self.diagnosis_model is None:
-            self.diagnosis_model = self.discover_metamodel.use_transformation_m2m(
-                self.fm_model, "pysat_diagnosis"
-            )
-
     def _as_configuration(
         self, configuration: Union[str, Dict[str, Any], Configuration]
     ) -> Configuration:
         """Resolve a configuration argument into a Configuration model.
 
-        Accepts a path to a configuration file (read via the configuration
-        transformation), a ``{feature: value}`` mapping, or an already-built
-        Configuration. This lets callers that already hold a configuration in
-        memory (e.g. an interactive UI) pass it directly without writing a file.
+        Accepts a path to a configuration file (read via the configuration transformation), a
+        ``{feature: value}`` mapping, or an already-built Configuration.
         """
         if isinstance(configuration, Configuration):
             return configuration
         if isinstance(configuration, dict):
             return Configuration(configuration)
-        return self.discover_metamodel.use_transformation_t2m(
-            configuration, "configuration"
-        )
-
-    def atomic_sets(self) -> Union[None, List[List[Any]]]:
-        """
-        This operation is used to find the atomic sets in a model:
-        It returns the atomic sets if they are found in the model.
-        If the model does not follow the UVL specification, an
-        exception is raised and the operation returns False.
-        """
-
-        # Try to use the Find operation, which returns the atomic sets if they are found
-        try:
-            atomic_sets = self.discover_metamodel.use_operation(
-                self.fm_model, "FMAtomicSets"
-            ).get_result()
-            result = []
-            for atomic_set in atomic_sets:
-                partial_set = []
-                for feature in atomic_set:
-                    partial_set.append(feature.name)
-                result.append(partial_set)
-            return result
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def language_level(self) -> Union[None, Any]:
-        """Return the UVL language level."""
-
-        try:
-            result = self.discover_metamodel.use_operation(
-                self.fm_model, "FMLanguageLevel"
-            ).get_result()
-            return result
-        except FlamaException as exception:
-            print(f"Error: {exception}")
-            return None
-
-    def average_branching_factor(self) -> Union[None, float]:
-        """
-        This refers to the average number of child features that a parent feature has in a
-        feature model. It's calculated by dividing the total number of child features by the
-        total number of parent features. A high average branching factor indicates a complex
-        feature model with many options, while a low average branching factor indicates a
-        simpler model.
-        """
-
-        # Try to use the Find operation, which returns the atomic sets if they are found
-        try:
-            result = self.discover_metamodel.use_operation(
-                self.fm_model, "FMAverageBranchingFactor"
-            ).get_result()
-            return result
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def count_leafs(self) -> Union[None, int]:
-        """
-        This operation counts the number of leaf features in a feature model. Leaf features
-        are those that do not have any child features. They represent the most specific
-        options in a product line.
-        """
-
-        # Try to use the Find operation, which returns the atomic sets if they are found
-        try:
-            result = self.discover_metamodel.use_operation(
-                self.fm_model, "FMCountLeafs"
-            ).get_result()
-            return result
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def estimated_number_of_configurations(self) -> Union[None, int]:
-        """
-        This is an estimate of the total number of different products that can be produced
-        from a feature model. It's calculated by considering all possible combinations of
-        features. This can be a simple multiplication if all features are independent, but
-        in most cases, constraints and dependencies between features need to be taken
-        into account.
-        """
-
-        # Try to use the Find operation, which returns the atomic sets if they are found
-        try:
-            result = self.discover_metamodel.use_operation(
-                self.fm_model, "FMEstimatedConfigurationsNumber"
-            ).get_result()
-            return result
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def feature_ancestors(self, feature_name: str) -> Union[None, List[str]]:
-        """
-        These are the features that are directly or indirectly the parent of a given feature in
-        a feature model. Ancestors of a feature are found by traversing up the feature hierarchy.
-        This information can be useful to understand the context and dependencies of a feature.
-        """
-        # Try to use the Find operation, which returns the atomic sets if they are found
-        try:
-            operation = self.discover_metamodel.get_operation(self.fm_model, "FMFeatureAncestors")
-            operation.set_feature(self.fm_model.get_feature_by_name(feature_name))
-            operation.execute(self.fm_model)
-            flama_result = operation.get_result()
-            result = []
-            for res in flama_result:
-                result.append(res.name)
-            return result
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def leaf_features(self) -> Union[None, List[str]]:
-        """
-        This operation is used to find leaf features in a model:
-        It returns the leaf features if they are found in the model.
-        If the model does not follow the UVL specification, an
-        exception is raised and the operation returns False.
-
-        Traditionally you would use the flama tool by
-        features = discover_metamodel.use_operation_from_file('OperationString', model)
-        however, in this tool we know that this operation is from the fm metamodel,
-        so we avoid to execute the transformation if possible
-        """
+        return self.discover_metamodel.use_transformation_t2m(configuration, "configuration")
 
-        # Try to use the operation, which returns the leaf features if they are found
-        try:
-            features = self.discover_metamodel.use_operation(
-                self.fm_model, "FMLeafFeatures"
-            ).get_result()
-            leaf_features = []
-            for feature in features:
-                leaf_features.append(feature.name)
-            return leaf_features
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def max_depth(self) -> Union[None, int]:
-        """
-        This operation is used to find the max depth of the tree in a model:
-        It returns the max depth of the tree.
-        If the model does not follow the UVL specification, an
-        exception is raised and the operation returns False.
-        """
-
-        # Try to use the Find operation, which returns the max depth of the tree
-        try:
-            return self.discover_metamodel.use_operation(
-                self.fm_model, "FMMaxDepthTree"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    # The methods above rely on sat to be executed.
-    def core_features(self, backend: Optional[str] = None) -> Union[None, List[str]]:
-        """
-        These are the features that are present in all products of a product line.
-        In a feature model, they are the features that are mandatory and not optional.
-        Core features define the commonality among all products in a product line.
-
-        ``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to sat.
-        """
-        try:
-            model = self._select_backend(backend, Backend.SAT)
-            return self.discover_metamodel.use_operation(model, "CoreFeatures").get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def dead_features(self, backend: Optional[str] = None) -> Union[None, List[str]]:
-        """
-        These are features that, due to the constraints and dependencies in the
-        feature model, cannot be included in any valid product. Dead features are usually
-        a sign of an error in the feature model.
-
-        ``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to sat.
-        """
-        try:
-            model = self._select_backend(backend, Backend.SAT)
-            return self.discover_metamodel.use_operation(model, "DeadFeatures").get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def false_optional_features(self, backend: Optional[str] = None) -> Union[None, List[str]]:
-        """
-        These are features that appear to be optional in the feature model, but due to the
-        constraints and dependencies, must be included in every valid product. Like dead features,
-        false optional features are usually a sign of an error in the feature model.
-
-        ``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to sat.
-        """
-        try:
-            model = self._select_backend(backend, Backend.SAT)
-            return self.discover_metamodel.use_operation(
-                model, "FalseOptionalFeatures"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def filter(self, configuration_path: str) -> Union[None, List[Configuration]]:
-        """
-        This operation selects a subset of the products of a product line based on certain
-        criteria. For example, you might filter the products to only include those that
-        contain a certain feature.
-
-        ``configuration_path`` accepts a configuration file path, a ``{feature: value}``
-        mapping, or a Configuration object.
-        """
-        try:
-            self._transform_to_sat()
-            configuration = self._as_configuration(configuration_path)
-            operation = self.discover_metamodel.get_operation(self.sat_model, "PySATFilter")
-            operation.set_configuration(configuration)
-            operation.execute(self.sat_model)
+    def _model_for(
+        self, descriptor: OperationDescriptor, backend_arg: Optional[str]
+    ) -> VariabilityModel:
+        """Resolve the operation's target model, lazily transforming (and caching) fm->backend.
+
+        The backend is the per-call one > workspace default > the operation's default (for
+        backend-selectable ops), or simply the fixed default. When it resolves to ``None`` (an
+        fm-level op, or a selectable op with no backend requested) the operation runs on the feature
+        model directly. Otherwise the name is mapped to a transformation extension (only
+        ``sat -> pysat`` differs) and cached per extension.
+        """
+        if descriptor.selectable_backend:
+            resolved = backend_arg or self.backend or descriptor.default_backend
+        else:
+            resolved = descriptor.default_backend
+        if resolved is None:
+            return self.fm_model
+        name = resolved.value if isinstance(resolved, Backend) else str(resolved)
+        extension = _BACKEND_ALIAS.get(name, name)
+        if extension not in self._backend_models:
+            self._backend_models[extension] = self.discover_metamodel.use_transformation_m2m(
+                self.fm_model, extension)
+        return self._backend_models[extension]
+
+    def _run_operation(
+        self, descriptor: OperationDescriptor, call_kwargs: Dict[str, Any]
+    ) -> Any:
+        """Resolve model + operation, wire inputs, execute, and marshal the result.
+
+        Preserves the facade's historical contract: any :class:`FlamaException` is logged and the
+        call returns ``None``.
+        """
+        try:
+            backend_arg = call_kwargs.pop('backend', None)
+            model = self._model_for(descriptor, backend_arg)
+            operation = self.discover_metamodel.get_operation(model, descriptor.operation)
+            if descriptor.input_adapter is not None:
+                descriptor.input_adapter(operation, self, call_kwargs)
+            else:
+                for input_spec in descriptor.inputs:
+                    value = call_kwargs.get(input_spec.name)
+                    if value is None:
+                        continue
+                    if input_spec.kind == 'configuration':
+                        value = self._as_configuration(value)
+                    if input_spec.setter is not None:
+                        getattr(operation, input_spec.setter)(value)
+            operation.execute(model)
             result = operation.get_result()
+            if descriptor.result_adapter is not None:
+                result = descriptor.result_adapter(result)
             return result
         except FlamaException as exception:
             logger.error("Error: %s", exception)
             return None
 
-    def configurations_number(self, backend: Optional[str] = None) -> Union[None, int]:
-        """
-        This is the total number of different full configurations that can be
-        produced from a feature model. It's calculated by considering all possible
-        combinations of features, taking into account the constraints and
-        dependencies between features.
-
-        ``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to bdd.
-        """
-        try:
-            model = self._select_backend(backend, Backend.BDD)
-            return self.discover_metamodel.use_operation(
-                model, "ConfigurationsNumber"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def configurations(self, backend: Optional[str] = None) -> Union[None, List[Configuration]]:
-        """
-        These are the individual outcomes that can be produced from a feature model. Each product
-        is a combination of features that satisfies all the constraints and dependencies in the
-        feature model.
-
-        ``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to bdd.
-        """
-        try:
-            model = self._select_backend(backend, Backend.BDD)
-            return self.discover_metamodel.use_operation(model, "Configurations").get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def commonality(self, configuration_path: str) -> Union[None, float]:
-        """
-        This is a measure of how often a feature appears in the products of a
-        product line. It's usually expressed as a percentage. A feature with
-        100 per cent commonality is a core feature, as it appears in all products.
-
-        ``configuration_path`` accepts a configuration file path, a ``{feature: value}``
-        mapping, or a Configuration object.
-        """
-        try:
-            self._transform_to_sat()
-            configuration = self._as_configuration(configuration_path)
-
-            operation = self.discover_metamodel.get_operation(self.sat_model, "PySATCommonality")
-            operation.set_configuration(configuration)
-            operation.execute(self.sat_model)
-            return operation.get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def satisfiable_configuration(
-        self,
-        configuration_path: str,
-        full_configuration: bool = False,
-        backend: Optional[str] = None,
-    ) -> Union[None, bool]:
-        """
-        This is a product that is produced from a valid configuration of features. A valid
-        product satisfies all the constraints and dependencies in the feature model.
 
-        ``configuration_path`` accepts a configuration file path, a ``{feature: value}``
-        mapping, or a Configuration object.
-        ``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to sat.
-        """
-        try:
-            model = self._select_backend(backend, Backend.SAT)
-            configuration = self._as_configuration(configuration_path)
-            operation = self.discover_metamodel.get_operation(
-                model, "SatisfiableConfiguration"
-            )
-
-            configuration.is_full = bool(full_configuration)
-
-            operation.set_configuration(configuration)
-            operation.execute(model)
-            return operation.get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def satisfiable(self, backend: Optional[str] = None) -> Union[None, bool]:
-        """
-        In the context of feature models, this usually refers to whether the feature model itself
-        satisfies all the constraints and dependencies. A a valid feature model is one that
-        does encodes at least a single valid product.
-
-        ``backend`` selects the analysis plugin ("sat", "bdd" or "z3"); defaults to sat.
-        """
-        try:
-            model = self._select_backend(backend, Backend.SAT)
-            return self.discover_metamodel.use_operation(model, "Satisfiable").get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    # FM-based operations
-
-    def metrics(self) -> Union[None, List[Dict[str, Any]]]:
-        """
-        Returns a collection of structural metrics for the feature model, such as number of
-        features, constraints, relations, and complexity indicators.
-        """
-        try:
-            return self.discover_metamodel.use_operation(
-                self.fm_model, "FMMetrics"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def variation_points(self) -> Union[None, Dict[str, List[str]]]:
-        """
-        Returns the variation points of the feature model. A variation point is a feature that
-        has at least one non-mandatory child, representing a decision point in the model.
-        The result maps each variation point name to the list of its variant feature names.
-        """
-        try:
-            raw = self.discover_metamodel.use_operation(
-                self.fm_model, "FMVariationPoints"
-            ).get_result()
-            return {vp.name: [v.name for v in variants] for vp, variants in raw.items()}
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    # SAT-based operations
-
-    def backbone(self) -> Union[None, Dict[str, List[Any]]]:
-        """
-        Returns the backbone of the feature model: the set of features that must always be
-        selected (core) and those that must never be selected (dead) across all valid
-        configurations, grouped under 'core' and 'dead' keys.
-        """
-        try:
-            self._transform_to_sat()
-            return self.discover_metamodel.use_operation(
-                self.sat_model, "PySATBackbone"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    # BDD-based operations
-
-    def homogeneity(self) -> Union[None, float]:
-        """
-        Measures how similar the products of the feature model are to each other. It is
-        computed as the average commonality factor across all features. A value of 1.0 means
-        all products are identical; lower values indicate more diversity.
-        """
-        try:
-            self._transform_to_bdd()
-            return self.discover_metamodel.use_operation(
-                self.bdd_model, "BDDHomogeneity"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def product_distribution(self) -> Union[None, List[int]]:
-        """
-        Returns the distribution of products by number of activated features. The value at
-        index i is the count of valid configurations that have exactly i features selected.
-        """
-        try:
-            self._transform_to_bdd()
-            return self.discover_metamodel.use_operation(
-                self.bdd_model, "BDDProductDistribution"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def variability(self) -> Union[None, Tuple[float, float]]:
-        """
-        Returns a tuple of (total_variability, partial_variability). Total variability is the
-        ratio of valid configurations to the theoretical maximum; partial variability is the
-        ratio relative to only the variant features.
-        """
-        try:
-            self._transform_to_bdd()
-            return self.discover_metamodel.use_operation(
-                self.bdd_model, "BDDVariability"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def variant_features(self) -> Union[None, List[str]]:
-        """
-        Returns the features that are neither core nor dead — they appear in some but not all
-        valid configurations. These are the features that actually vary across products.
-        """
-        try:
-            self._transform_to_bdd()
-            return self.discover_metamodel.use_operation(
-                self.bdd_model, "BDDVariantFeatures"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def unique_features(self) -> Union[None, List[str]]:
-        """
-        Returns features that appear in exactly one valid configuration. These features
-        uniquely identify a single product in the product line.
-        """
-        try:
-            self._transform_to_bdd()
-            return self.discover_metamodel.use_operation(
-                self.bdd_model, "BDDUniqueFeatures"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def pure_optional_features(self) -> Union[None, List[str]]:
-        """
-        Returns features with a feature inclusion probability of exactly 0.5, meaning they
-        are selected in exactly half of the valid configurations. These are the most
-        unconstrained optional features.
-        """
-        try:
-            self._transform_to_bdd()
-            return self.discover_metamodel.use_operation(
-                self.bdd_model, "BDDPureOptionalFeatures"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def feature_inclusion_probability(self) -> Union[None, Dict[str, float]]:
-        """
-        Returns a mapping from each feature name to its inclusion probability: the fraction
-        of valid configurations in which that feature is selected. Core features have
-        probability 1.0 and dead features have probability 0.0.
-        """
-        try:
-            self._transform_to_bdd()
-            return self.discover_metamodel.use_operation(
-                self.bdd_model, "BDDFeatureInclusionProbability"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def configurations_with_n_features(self, n: int) -> Union[None, List[Configuration]]:
-        """
-        Returns all valid configurations that have exactly n features selected.
-        """
-        try:
-            self._transform_to_bdd()
-            operation = self.discover_metamodel.get_operation(
-                self.bdd_model, "BDDConfigurationsWithNFeatures"
-            )
-            operation.set_n_features(n)
-            operation.execute(self.bdd_model)
-            return list(operation.get_result())
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def sampling(
-        self, size: int, with_replacement: bool = False, backend: Optional[str] = None
-    ) -> Union[None, List[Configuration]]:
-        """
-        Returns a random sample of valid configurations of the given size. When
-        with_replacement is True, the same configuration may appear more than once.
-
-        ``backend`` selects the analysis plugin; defaults to bdd. Only sat and bdd
-        implement sampling.
-        """
-        try:
-            model = self._select_backend(backend, Backend.BDD)
-            operation = self.discover_metamodel.get_operation(model, "Sampling")
-            operation.set_sample_size(size)
-            operation.set_with_replacement(with_replacement)
-            operation.execute(model)
-            return operation.get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    # Z3-based operations
-
-    def all_feature_bounds(self) -> Union[None, Dict[str, Dict[str, Any]]]:
-        """
-        Returns the value bounds for all typed (Integer, Real, String) attribute features in
-        the model. Each entry maps a feature name to a dict with 'min', 'max', and 'bounded'
-        keys. Requires the z3 metamodel plugin.
-        """
-        try:
-            self._transform_to_z3()
-            return self.discover_metamodel.use_operation(
-                self.z3_model, "Z3AllFeatureBounds"
-            ).get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def feature_bounds(self, variable_name: str) -> Union[None, Dict[str, Any]]:
-        """
-        Returns the value bounds for a specific typed attribute feature. The result dict
-        contains 'min', 'max', and 'bounded' keys. Requires the z3 metamodel plugin.
-        """
-        try:
-            self._transform_to_z3()
-            operation = self.discover_metamodel.get_operation(self.z3_model, "Z3FeatureBounds")
-            operation.set_variable_name(variable_name)
-            operation.execute(self.z3_model)
-            return operation.get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    # Diagnosis-based operations
-
-    def diagnosis(
-        self,
-        configuration_path: str,
-        test_case_path: Optional[str] = None,
-        max_diagnoses: Optional[int] = None,
-    ) -> Union[None, List[str]]:
-        """
-        Returns a list of diagnoses explaining why a configuration is not valid against the
-        feature model: each diagnosis is a minimal set of constraints whose removal would
-        resolve the inconsistency. Requires the pysat_diagnosis plugin.
-
-        ``configuration_path`` accepts a configuration file path, a ``{feature: value}``
-        mapping, or a Configuration object. ``test_case_path`` is optional and, when given,
-        diagnoses against that expected outcome instead; it accepts the same input types.
-        """
-        try:
-            self._transform_to_diagnosis()
-            operation = self.discover_metamodel.get_operation(
-                self.diagnosis_model, "PySATDiagnosis"
-            )
-            if configuration_path is not None:
-                operation.set_configuration(self._as_configuration(configuration_path))
-            if test_case_path is not None:
-                operation.set_test_case(self._as_configuration(test_case_path))
-            if max_diagnoses is not None:
-                operation.set_max_diagnoses(max_diagnoses)
-            operation.execute(self.diagnosis_model)
-            return operation.get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
-
-    def conflict(
-        self,
-        configuration_path: str,
-        test_case_path: Optional[str] = None,
-        max_conflicts: Optional[int] = None,
-    ) -> Union[None, List[str]]:
-        """
-        Returns a list of conflict sets: minimal subsets of the model constraints that are
-        inconsistent with the given configuration. Requires the pysat_diagnosis plugin.
-
-        ``configuration_path`` accepts a configuration file path, a ``{feature: value}``
-        mapping, or a Configuration object. ``test_case_path`` is optional and, when given,
-        looks for conflicts against that expected outcome instead; same input types.
-        """
-        try:
-            self._transform_to_diagnosis()
-            operation = self.discover_metamodel.get_operation(
-                self.diagnosis_model, "PySATConflict"
-            )
-            if configuration_path is not None:
-                operation.set_configuration(self._as_configuration(configuration_path))
-            if test_case_path is not None:
-                operation.set_test_case(self._as_configuration(test_case_path))
-            if max_conflicts is not None:
-                operation.set_max_conflicts(max_conflicts)
-            operation.execute(self.diagnosis_model)
-            return operation.get_result()
-        except FlamaException as exception:
-            logger.error("Error: %s", exception)
-            return None
+# One discovery instance, reused to install the operations and to run producers (which have no
+# per-facade instance to hold their own).
+_DISCOVERY = DiscoverMetamodels()
+
+
+def _run_producer(descriptor: OperationDescriptor, call_kwargs: Dict[str, Any]) -> Any:
+    """Run a 'producer' operation — one that *creates* a model instead of analysing one.
+
+    Producers take no input model, so the operation is instantiated directly and executed with no
+    model. Same FlamaException -> None contract as :meth:`FLAMAFeatureModel._run_operation`.
+    """
+    try:
+        operation_class = next(
+            (op for op in _DISCOVERY.get_operations() if op.__name__ == descriptor.operation), None)
+        if operation_class is None:
+            raise FlamaException(f"Operation '{descriptor.operation}' was not discovered")
+        operation = operation_class()
+        for input_spec in descriptor.inputs:
+            value = call_kwargs.get(input_spec.name)
+            if value is not None and input_spec.setter is not None:
+                getattr(operation, input_spec.setter)(value)
+        operation.execute(None)
+        result = operation.get_result()
+        if descriptor.result_adapter is not None:
+            result = descriptor.result_adapter(result)
+        return result
+    except FlamaException as exception:
+        logger.error("Error: %s", exception)
+        return None
+
+
+def _make_operation_method(descriptor: OperationDescriptor) -> Any:
+    """Build a real callable from a descriptor.
+
+    Operations become instance methods ``(self, *inputs[, backend])`` dispatching via
+    ``_run_operation``; producers become plain functions ``(*inputs)`` (wrapped as a
+    ``staticmethod`` by the installer) dispatching via ``_run_producer``.
+    """
+    producer = descriptor.kind == 'producer'
+    parameters = [] if producer else [
+        inspect.Parameter('self', inspect.Parameter.POSITIONAL_OR_KEYWORD)]
+    for input_spec in descriptor.inputs:
+        default = inspect.Parameter.empty if input_spec.required else input_spec.default
+        parameters.append(inspect.Parameter(
+            input_spec.name, inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            default=default, annotation=input_spec.type))
+    if descriptor.selectable_backend:
+        parameters.append(inspect.Parameter(
+            'backend', inspect.Parameter.POSITIONAL_OR_KEYWORD, default=None,
+            annotation=Optional[str]))
+    signature = inspect.Signature(parameters)
+
+    def method(*args: Any, **kwargs: Any) -> Any:
+        bound = signature.bind(*args, **kwargs)
+        bound.apply_defaults()
+        call_kwargs = dict(bound.arguments)
+        if producer:
+            return _run_producer(descriptor, call_kwargs)
+        instance = call_kwargs.pop('self')
+        return instance._run_operation(descriptor, call_kwargs)
+
+    method.__name__ = descriptor.name
+    method.__qualname__ = f'{FLAMAFeatureModel.__name__}.{descriptor.name}'
+    method.__doc__ = descriptor.doc
+    method.__signature__ = signature  # type: ignore[attr-defined]
+    # Let the CLI/REST/tests tell analysis ops from producers/transformers without re-discovering.
+    setattr(method, '_facade_kind', descriptor.kind)
+    setattr(method, '_facade_descriptor', descriptor)
+    return method
+
+
+def _install_operations(cls: type) -> None:
+    for name, descriptor in _DISCOVERY.available_operations().items():
+        method = _make_operation_method(descriptor)
+        setattr(cls, name, staticmethod(method) if descriptor.kind == 'producer' else method)
+
+
+_install_operations(FLAMAFeatureModel)

flamapy/interfaces/python/flamapy_feature_model.pyi

@@ -0,0 +1,63 @@
+# Auto-generated by flamapy.interfaces.python._stub — do not edit by hand.
+# Regenerate with: python -m flamapy.interfaces.python._stub
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from flamapy.metamodels.configuration_metamodel.models import Configuration
+from flamapy.metamodels.fm_metamodel.models import FeatureModel
+
+
+class Backend(str, Enum):
+    SAT = ...
+    BDD = ...
+    Z3 = ...
+    SHARPSAT = ...
+
+
+class FLAMAFeatureModel:
+    model_path: str
+    fm_model: FeatureModel
+    backend: Optional[Backend]
+    def __init__(self, model_path: str, backend: Optional[str] = ...) -> None: ...
+    def all_feature_bounds(self) -> Union[None, Dict[str, Dict[str, Any]]]: ...
+    def atomic_sets(self) -> Union[None, List[List[Any]]]: ...
+    def attribute_optimization(self, objectives: Any, backend: Optional[str] = ...) -> Union[None, List[Configuration]]: ...
+    def average_branching_factor(self) -> Union[None, float]: ...
+    def backbone(self) -> Union[None, Dict[str, List[Any]]]: ...
+    def commonality(self, configuration_path: str) -> Union[None, float]: ...
+    def configuration_conflict(self, configuration_path: str) -> Union[None, List[Any]]: ...
+    def configuration_repair(self, configuration_path: str) -> Union[None, List[Any]]: ...
+    def configurations(self, backend: Optional[str] = ...) -> Union[None, List[Configuration]]: ...
+    def configurations_number(self, backend: Optional[str] = ...) -> Union[None, int]: ...
+    def configurations_with_n_features(self, n: int) -> Union[None, List[Configuration]]: ...
+    def conflict(self, configuration_path: str, test_case_path: Optional[str] = ..., max_conflicts: Optional[int] = ...) -> Union[None, List[str]]: ...
+    def core_features(self, backend: Optional[str] = ...) -> Union[None, List[str]]: ...
+    def count_leafs(self) -> Union[None, int]: ...
+    def dead_features(self, backend: Optional[str] = ...) -> Union[None, List[str]]: ...
+    def diagnosis(self, configuration_path: str, test_case_path: Optional[str] = ..., max_diagnoses: Optional[int] = ...) -> Union[None, List[str]]: ...
+    def estimated_number_of_configurations(self) -> Union[None, int]: ...
+    def false_optional_features(self, backend: Optional[str] = ...) -> Union[None, List[str]]: ...
+    def feature_ancestors(self, feature_name: str) -> Union[None, List[str]]: ...
+    def feature_bounds(self, variable_name: str) -> Union[None, Dict[str, Any]]: ...
+    def feature_explanation(self, configuration_path: str, feature_name: str) -> Union[None, List[Any]]: ...
+    def feature_inclusion_probability(self) -> Union[None, Dict[str, float]]: ...
+    def filter(self, configuration_path: str) -> Union[None, List[Configuration]]: ...
+    def generate_random_attribute(self, name: str, min_value: int = ..., max_value: int = ..., only_leaf_features: bool = ...) -> FeatureModel: ...
+    @staticmethod
+    def generate_random_feature_model(num_features: int = ..., max_constraints: int = ..., seed: int = ..., void: bool = ..., language_level: str = ...) -> FeatureModel: ...
+    def homogeneity(self) -> Union[None, float]: ...
+    def language_level(self) -> Union[None, Any]: ...
+    def leaf_features(self) -> Union[None, List[str]]: ...
+    def max_depth(self) -> Union[None, int]: ...
+    def metrics(self) -> Union[None, List[Dict[str, Any]]]: ...
+    def minimum_configuration(self, backend: Optional[str] = ...) -> Union[None, Configuration]: ...
+    def product_distribution(self) -> Union[None, List[int]]: ...
+    def pure_optional_features(self) -> Union[None, List[str]]: ...
+    def sampling(self, size: int, with_replacement: bool = ..., backend: Optional[str] = ...) -> Union[None, List[Configuration]]: ...
+    def satisfiable(self, backend: Optional[str] = ...) -> Union[None, bool]: ...
+    def satisfiable_configuration(self, configuration_path: str, full_configuration: bool = ..., backend: Optional[str] = ...) -> Union[None, bool]: ...
+    def t_wise_sampling(self, t: int = ..., backend: Optional[str] = ...) -> Union[None, List[Configuration]]: ...
+    def unique_features(self) -> Union[None, List[str]]: ...
+    def variability(self) -> Union[None, Tuple[float, float]]: ...
+    def variant_features(self) -> Union[None, List[str]]: ...
+    def variation_points(self) -> Union[None, Dict[str, List[str]]]: ...

{flamapy-2.6.0.dev4.dist-info → flamapy-2.6.0.dev11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy
-Version: 2.6.0.dev4
+Version: 2.6.0.dev11
 Summary: Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richer API and a complete command line interface and documentation.
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,11 +8,11 @@ Project-URL: Homepage, https://github.com/flamapy/flamapy-feature-model
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.6.0.dev4
-Requires-Dist: flamapy-fm~=2.6.0.dev4
-Requires-Dist: flamapy-sat~=2.6.0.dev4
-Requires-Dist: flamapy-bdd~=2.6.0.dev4
-Requires-Dist: flamapy-z3~=2.6.0.dev4
+Requires-Dist: flamapy-fw~=2.6.0.dev11
+Requires-Dist: flamapy-fm~=2.6.0.dev11
+Requires-Dist: flamapy-sat~=2.6.0.dev11
+Requires-Dist: flamapy-bdd~=2.6.0.dev11
+Requires-Dist: flamapy-z3~=2.6.0.dev11
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"

flamapy-2.6.0.dev11.dist-info/RECORD

@@ -0,0 +1,11 @@
+flamapy/commands/__init__.py,sha256=rajfqLxDAa5E4glNlLfUXQbIl5ZcgkGI6kTBKM9apSM,10144
+flamapy/interfaces/python/__init__.py,sha256=NVQH1l6O9ElD8YvUVBXJN0Y_ETmu3AbyQBZJJ9qiuoU,86
+flamapy/interfaces/python/_stub.py,sha256=SDlbrXrfQaJpgTzuScY-Q9IrkarGO96ad463NL0RJMY,2822
+flamapy/interfaces/python/flamapy_feature_model.py,sha256=sBZffI8CA4NA7Tzg9q7OaTCDKTV-EY-tWKQ8kdEEBkY,9840
+flamapy/interfaces/python/flamapy_feature_model.pyi,sha256=VdGtS3KdobqOEQfmvO_HTo2JkCNRB7UOWurKG4Xet64,4336
+flamapy-2.6.0.dev11.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+flamapy-2.6.0.dev11.dist-info/METADATA,sha256=NirN5M8AxSAKjhVaN6dk-7a02UCU1odFpcdhaDDCgiE,1271
+flamapy-2.6.0.dev11.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+flamapy-2.6.0.dev11.dist-info/entry_points.txt,sha256=CS_W4K9LW9xOf-7ymWD58KklNHBnhMHm0RXAZ9JLgVo,57
+flamapy-2.6.0.dev11.dist-info/top_level.txt,sha256=2YBI9dg4GVk28AJuyNu6dldi5Riwt5SP0zpNe2lSU5M,8
+flamapy-2.6.0.dev11.dist-info/RECORD,,

flamapy-2.6.0.dev4.dist-info/RECORD

@@ -1,9 +0,0 @@
-flamapy/commands/__init__.py,sha256=S9KJB8u4Ww5_6KQYs70iwQFbtDm08J7UvE7vxAB6DeE,6609
-flamapy/interfaces/python/__init__.py,sha256=NVQH1l6O9ElD8YvUVBXJN0Y_ETmu3AbyQBZJJ9qiuoU,86
-flamapy/interfaces/python/flamapy_feature_model.py,sha256=ojxMc3XtAvnBs9T7ETLo1rFpt1g0XRMc8MRdHf1HJ2w,30598
-flamapy-2.6.0.dev4.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-flamapy-2.6.0.dev4.dist-info/METADATA,sha256=jbaO1-9RFf15ynsn6ftjbaoy0eV8Mp3JjwAKSowwD3o,1265
-flamapy-2.6.0.dev4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-flamapy-2.6.0.dev4.dist-info/entry_points.txt,sha256=CS_W4K9LW9xOf-7ymWD58KklNHBnhMHm0RXAZ9JLgVo,57
-flamapy-2.6.0.dev4.dist-info/top_level.txt,sha256=2YBI9dg4GVk28AJuyNu6dldi5Riwt5SP0zpNe2lSU5M,8
-flamapy-2.6.0.dev4.dist-info/RECORD,,