flamapy 2.5.0.dev0__tar.gz → 2.6.0__tar.gz

flamapy-2.6.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: flamapy
+Version: 2.6.0
+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
+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
+Requires-Dist: flamapy-fm~=2.6.0
+Requires-Dist: flamapy-sat~=2.6.0
+Requires-Dist: flamapy-bdd~=2.6.0
+Requires-Dist: flamapy-z3~=2.6.0
+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
+
+The flamapy feature-model distribution: a meta-package that installs the
+framework and the feature-model analysis plugins, and provides the command-line
+interface and the easy-to-use Python facade (`FLAMAFeatureModel`).
+
+**Documentation:** https://docs.flamapy.org
+
+## Installation
+
+```bash
+pip install flamapy
+```

flamapy-2.6.0/README.md

@@ -0,0 +1,13 @@
+# flamapy
+
+The flamapy feature-model distribution: a meta-package that installs the
+framework and the feature-model analysis plugins, and provides the command-line
+interface and the easy-to-use Python facade (`FLAMAFeatureModel`).
+
+**Documentation:** https://docs.flamapy.org
+
+## Installation
+
+```bash
+pip install flamapy
+```

flamapy-2.6.0/flamapy/commands/__init__.py

@@ -0,0 +1,254 @@
+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, Union, get_args, get_origin
+from types import FunctionType
+
+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
+        MANUAL_COMMANDS.append((name, description, func, args))
+
+        @wraps(func)
+        def wrapper(*func_args, **func_kwargs):  # type: ignore
+            return func(*func_args, **func_kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+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'
+        descriptor = getattr(method, "_facade_descriptor", None)
+        commands.append((name, docstring or "", method, parameters, descriptor))
+    return commands
+
+
+@command(
+    "generate_plugin",
+    "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
+    name = args.name
+    ext = args.extension
+    dst = args.path
+    src = "skel_metamodel/"
+
+    # Check DST exist
+    if not os.path.isdir(dst):
+        print(f"Folder {dst} not exist")
+        sys.exit()
+
+    # Check DST is empty
+    if len(os.listdir(dst)) != 0:
+        print(f"Folder {dst} is not empty")
+        sys.exit()
+
+    # Check DST has permissions to WRITE
+    if not os.access(dst, os.W_OK):
+        print(f"Folder {dst} has not write permissions")
+        sys.exit()
+
+    # Generating structure
+    print("Generating structure ...")
+
+    copy_files = copytree(src, dst, dirs_exist_ok=True)
+
+    for copy_file in Path(copy_files).glob("**/*"):
+        if copy_file.is_dir():
+            continue
+        with open(copy_file, "r", encoding="utf-8") as file:
+            lines = file.readlines()
+        with open(copy_file, "w", encoding="utf-8") as filewrite:
+            for line in lines:
+                out_line = line.replace("__NAME__", name.capitalize()).replace("__EXT__", ext)
+                filewrite.write(out_line)
+
+    os.rename(
+        os.path.join(dst, "flamapy/metamodels/__NAME__"),
+        os.path.join(dst, f"flamapy/metamodels/{name}"),
+    )
+    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=_summary(docstring), description=docstring)
+        subparser.add_argument("model_path", type=str, help="Path to the feature model file")
+        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(
+                        f"--{arg_name}",
+                        action=argparse.BooleanOptionalAction,
+                        default=param.default,
+                        help="Optional bool",
+                    )
+                else:  # Optional argument
+                    subparser.add_argument(
+                        f"--{arg_name}",
+                        type=arg_type,
+                        default=param.default,
+                        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=_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)
+        subparser.set_defaults(func=func)
+
+
+def execute_command(args: argparse.Namespace) -> None:
+    try:
+        if hasattr(args, "method_name"):
+            cls_instance = FLAMAFeatureModel(args.model_path)
+            method_parameters = [param.name for param in args.parameters]
+            command_args = {k: v for k, v in vars(args).items() if k in method_parameters}
+            method = getattr(cls_instance, args.method_name)
+            result = method(**command_args)
+            if result is not None:
+                print(result)
+        else:
+            func = args.func
+            command_args = {k: v for k, v in vars(args).items() if k != "func"}
+            result = func(args)
+            if result is not None:
+                print(result)
+    except FileNotFoundError as fnf_error:
+        print(f"File not found error: {fnf_error}")
+    except TypeError as type_error:
+        print(f"Type error: {type_error}")
+    except ValueError as value_error:
+        print(f"Value error: {value_error}")
+    except KeyError as key_error:
+        print(f"Key error: {key_error}")
+    except AttributeError as attr_error:
+        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", metavar="COMMAND", title="commands")
+
+    dynamic_commands = extract_commands(FLAMAFeatureModel)
+    setup_dynamic_commands(subparsers, dynamic_commands)
+    setup_manual_commands(subparsers, MANUAL_COMMANDS)
+
+    args = parser.parse_args()
+
+    if args.command:
+        execute_command(args)
+    else:
+        print_command_overview(dynamic_commands)

flamapy-2.6.0/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-2.6.0/flamapy/interfaces/python/flamapy_feature_model.py

@@ -0,0 +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, Optional, Union
+
+from flamapy.core.discover import DiscoverMetamodels
+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 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:
+    """A feature model together with the analysis operations discovered from the installed plugins.
+
+    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.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 _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.
+        """
+        if isinstance(configuration, Configuration):
+            return configuration
+        if isinstance(configuration, dict):
+            return Configuration(configuration)
+        return self.discover_metamodel.use_transformation_t2m(configuration, "configuration")
+
+    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
+
+
+# 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-2.6.0/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]]]: ...