flamapy 2.6.0.dev5__tar.gz → 2.6.0.dev11__tar.gz

{flamapy-2.6.0.dev5 → flamapy-2.6.0.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy
-Version: 2.6.0.dev5
+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,19 +8,17 @@ 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.dev5
-Requires-Dist: flamapy-fm~=2.6.0.dev5
-Requires-Dist: flamapy-sat~=2.6.0.dev5
-Requires-Dist: flamapy-bdd~=2.6.0.dev5
-Requires-Dist: flamapy-z3~=2.6.0.dev5
+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"
 Requires-Dist: prospector; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
-Provides-Extra: sharpsat
-Requires-Dist: flamapy-sharpsat~=2.6.0.dev4; extra == "sharpsat"
 Dynamic: license-file
 
 # flamapy

{flamapy-2.6.0.dev5 → flamapy-2.6.0.dev11}/flamapy/commands/__init__.py

@@ -1,6 +1,8 @@
 import argparse
 import os
+import shutil
 import sys
+import textwrap
 from functools import wraps
 import inspect
 from pathlib import Path
@@ -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
@@ -107,8 +133,8 @@ def resolve_annotation_type(annotation: Any) -> type:
 
 
 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")
         for param in parameters:
             arg_name = param.name
@@ -135,7 +161,7 @@ def setup_dynamic_commands(subparsers, dynamic_commands):  # type: ignore
 
 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)
@@ -170,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)
@@ -183,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-2.6.0.dev11/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.dev11/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.dev11/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.dev5 → flamapy-2.6.0.dev11}/flamapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy
-Version: 2.6.0.dev5
+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,19 +8,17 @@ 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.dev5
-Requires-Dist: flamapy-fm~=2.6.0.dev5
-Requires-Dist: flamapy-sat~=2.6.0.dev5
-Requires-Dist: flamapy-bdd~=2.6.0.dev5
-Requires-Dist: flamapy-z3~=2.6.0.dev5
+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"
 Requires-Dist: prospector; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
-Provides-Extra: sharpsat
-Requires-Dist: flamapy-sharpsat~=2.6.0.dev4; extra == "sharpsat"
 Dynamic: license-file
 
 # flamapy

{flamapy-2.6.0.dev5 → flamapy-2.6.0.dev11}/flamapy.egg-info/SOURCES.txt

@@ -10,10 +10,13 @@ flamapy.egg-info/requires.txt
 flamapy.egg-info/top_level.txt
 flamapy/commands/__init__.py
 flamapy/interfaces/python/__init__.py
+flamapy/interfaces/python/_stub.py
 flamapy/interfaces/python/flamapy_feature_model.py
+flamapy/interfaces/python/flamapy_feature_model.pyi
 tests/test_basic_units.py
 tests/test_cli_basic_units.py
+tests/test_descriptors_cover_facade.py
 tests/test_documentation_examples.py
 tests/test_fama_suite_bdd.py
 tests/test_fama_suite_sat.py
-tests/test_new_operations.py
+tests/test_optimization_and_sampling.py

flamapy-2.6.0.dev11/flamapy.egg-info/requires.txt

@@ -0,0 +1,12 @@
+flamapy-fw~=2.6.0.dev11
+flamapy-fm~=2.6.0.dev11
+flamapy-sat~=2.6.0.dev11
+flamapy-bdd~=2.6.0.dev11
+flamapy-z3~=2.6.0.dev11
+
+[dev]
+pytest
+pytest-mock
+prospector
+mypy
+coverage

{flamapy-2.6.0.dev5 → flamapy-2.6.0.dev11}/pyproject.toml

@@ -4,18 +4,18 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flamapy"
-version = "2.6.0.dev5"
+version = "2.6.0.dev11"
 description = "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."
 readme = "README.md"
 license = "GPL-3.0-or-later"
 authors = [{ name = "Flamapy", email = "flamapy@us.es" }]
 requires-python = ">=3.11"
 dependencies = [
-    "flamapy-fw~=2.6.0.dev5",
-    "flamapy-fm~=2.6.0.dev5",
-    "flamapy-sat~=2.6.0.dev5",
-    "flamapy-bdd~=2.6.0.dev5",
-    "flamapy-z3~=2.6.0.dev5",
+    "flamapy-fw~=2.6.0.dev11",
+    "flamapy-fm~=2.6.0.dev11",
+    "flamapy-sat~=2.6.0.dev11",
+    "flamapy-bdd~=2.6.0.dev11",
+    "flamapy-z3~=2.6.0.dev11",
 ]
 
 [project.optional-dependencies]
@@ -26,10 +26,6 @@ dev = [
     "mypy",
     "coverage",
 ]
-# Optional scalable counting/sampling backend (enables backend="sharpsat").
-sharpsat = [
-    "flamapy-sharpsat~=2.6.0.dev4",
-]
 
 [project.scripts]
 flamapy = "flamapy.commands:flamapy_cli"
@@ -40,6 +36,12 @@ Homepage = "https://github.com/flamapy/flamapy-feature-model"
 [tool.setuptools.packages.find]
 include = ["flamapy.*"]
 
+# Ship the PEP 561 marker + the generated facade type stub so type checkers and IDEs
+# can see the descriptor-generated FLAMAFeatureModel methods.
+[tool.setuptools.package-data]
+"flamapy" = ["py.typed"]
+"flamapy.interfaces.python" = ["flamapy_feature_model.pyi"]
+
 [tool.ruff]
 line-length = 100  # Matches max-line-length from pycodestyle
 target-version = "py311"
@@ -68,6 +70,7 @@ max-complexity = 10  # Equivalent to enabling mccabe in Prospector
 "__pycache__/*" = ["ALL"]
 "skel_metamodel/*" = ["ALL"]
 "flamapy/__init__.py" = ["ALL"]
+"*.pyi" = ["E501"]  # generated type stub: long one-line signatures are fine
 
 [tool.ruff.lint.pycodestyle]
 max-line-length = 100  # Matches your existing pycodestyle setting